From 2316d3d8c6f98cbe8f9c90d2958d12c3dd8520e2 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 27 Jul 2023 17:08:19 +0530 Subject: [PATCH 001/204] MOSIP-28585 --- .../apirig/admin/fw/util/AdminTestUtil.java | 131 +++++++++++++----- .../authentication/fw/util/ReportUtil.java | 14 +- .../apirig/customReport/EmailableReport.java | 11 +- .../apirig/global/utils/GlobalConstants.java | 4 + .../CertificateGenerationUtil.java | 5 + .../KeyCloakUserAndAPIKeyGeneration.java | 83 ++++++++++- .../MispPartnerAndLicenseKeyGeneration.java | 6 +- .../ida/certificate/PartnerRegistration.java | 23 ++- .../apirig/kernel/util/ConfigManager.java | 13 ++ .../kernel/util/KernelAuthentication.java | 45 +++++- .../kernel/util/KeycloakUserManager.java | 22 ++- .../testrig/apirig/service/BaseTestCase.java | 8 ++ .../apirig/testrunner/MosipTestRunner.java | 12 +- .../testrig/apirig/testscripts/BioAuth.java | 14 ++ .../testrig/apirig/testscripts/DemoAuth.java | 15 ++ .../DemoAuthSimplePostForAutoGenId.java | 24 ++++ .../apirig/testscripts/EsignetBioAuth.java | 15 ++ .../GetWithParamWithOtpGenerate.java | 8 +- .../testscripts/MultiFactorAuthNew.java | 14 ++ .../apirig/testscripts/OtpAuthNew.java | 14 ++ .../PatchWithBodyWithOtpGenerate.java | 8 +- .../PostWithAutogenIdWithOtpGenerate.java | 20 ++- .../PostWithBodyWithOtpGenerate.java | 8 +- .../apirig/testscripts/SimplePost.java | 8 +- .../testscripts/SimplePostForAutoGenId.java | 3 + .../apirig/testscripts/UpdateDraft.java | 4 +- .../main/resources/config/AuthPolicy2.json | 4 - .../main/resources/config/Kernel.properties | 40 +++--- .../resources/config/valueMapping.properties | 13 +- .../resources/ida/CreateVID/CreateVid.yml | 68 +++++++++ .../resources/ida/CreateVID/createVid.hbs | 11 ++ .../ida/CreateVID/createVidResult.hbs | 13 ++ .../main/resources/ida/DemoAuth/DemoAuth.yml | 24 ++-- .../resources/ida/DemoAuthOld/DemoAuth.yml | 10 +- .../main/resources/ida/EkycDemo/EkycDemo.yml | 14 +- .../resources/ida/EkycDemoOld/EkycDemo.yml | 14 +- .../ida/UpdateIdentity/UpdateIdentity.yml | 49 ------- .../ida/UpdateIdentity/updateIdentity.hbs | 12 +- .../testNgXmlFiles/authenticationApi.xml | 7 + 39 files changed, 627 insertions(+), 184 deletions(-) create mode 100644 automationtests/src/main/resources/ida/CreateVID/CreateVid.yml create mode 100644 automationtests/src/main/resources/ida/CreateVID/createVid.hbs create mode 100644 automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 41a42aa52c4..48b605457da 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -110,6 +110,8 @@ import io.mosip.testrig.apirig.testrunner.MosipTestRunner; import io.restassured.RestAssured; import io.restassured.response.Response; +import java.util.regex.Matcher; +import java.util.regex.Pattern; /** * @author Ravi Kant @@ -207,6 +209,8 @@ public static BioDataUtility getBioDataUtil() { /** The Constant SIGN_ALGO. */ private static final String SIGN_ALGO = "RS256"; public static final int OTP_CHECK_INTERVAL = 10000; + + private static String targetEnvVersion = ""; protected static boolean triggerESignetKeyGen1 = true; @@ -2379,7 +2383,10 @@ public String getAutogenIdKeyName(String testCaseName, String fieldName) { return null; int indexof = testCaseName.indexOf("_"); String autogenIdKeyName = testCaseName.substring(indexof + 1); - autogenIdKeyName = autogenIdKeyName + "_" + fieldName; + if ((!AdminTestUtil.isTargetEnvLTS()) && fieldName.equals("VID") && BaseTestCase.currentModule.equals("auth")) + autogenIdKeyName = autogenIdKeyName + "_" + fieldName.toLowerCase(); + else + autogenIdKeyName = autogenIdKeyName + "_" + fieldName; logger.info("key for testCase: " + testCaseName + " : " + autogenIdKeyName); return autogenIdKeyName; } @@ -3799,6 +3806,7 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { FileWriter fileWriter3 = null; FileReader fileReader = null; BufferedReader bufferedReader = null; + String mobileno = "7019858531"; try { JSONObject jObj = new JSONObject(schemaFile); @@ -3806,6 +3814,8 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { JSONObject objIDJson = objIDJson4.getJSONObject(GlobalConstants.IDENTITY); JSONObject objIDJson2 = objIDJson.getJSONObject(GlobalConstants.PROPERTIES); JSONArray objIDJson1 = objIDJson.getJSONArray(GlobalConstants.REQUIRED); +// objIDJson1.put("mobileno"); + objIDJson1.put("email"); fileWriter1 = new FileWriter(GlobalConstants.ADDIDENTITY_HBS); fileWriter1.write("{\n"); @@ -3835,7 +3845,14 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { studentJSON.put(GlobalConstants.LANGUAGE, BaseTestCase.getLanguageList().get(j)); if (objIDJson3.contains(GlobalConstants.FULLNAME) && regenerateHbs == true) { studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3 + "1")); // fullName1 - } else { + } + else if (objIDJson3.contains(GlobalConstants.FIRST_NAME) && regenerateHbs == true) { + studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3 + 1)); // fullName1 + } + else if (objIDJson3.contains(GlobalConstants.GENDER)) { + studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3)); + } + else { studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3) + BaseTestCase.getLanguageList().get(j)); } @@ -3866,19 +3883,31 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { fileWriter2.write("\t \"proofOfIdentity\": {\n" + "\t\t\"format\": \"txt\",\n" + "\t\t\"type\": \"DOC001\",\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t },\n"); } + + else if (objIDJson3.equals("mobileno")) { + fileWriter2.write(",\t \"" + objIDJson3 + "\":" + " " + "" + "" + mobileno + "" + "\n"); + } + + else if (objIDJson3.equals("email")) { + fileWriter2 + .write(",\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + "\n"); + } else if (objIDJson3.equals(GlobalConstants.INDIVIDUALBIOMETRICS)) { fileWriter2.write("\t \"individualBiometrics\": {\n" + "\t\t\"format\": \"cbeff\",\n" + "\t\t\"version\": 1,\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t }\n"); } + else if (objIDJson3.equals(GlobalConstants.PROOF_OF_ADDRESS)) { + fileWriter2.write("\t \"proofOfAddress\": {\n" + "\t\t\"format\": \"txt\",\n" + + "\t\t\"type\": \"DOC001\",\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t },\n"); + } else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { fileWriter2.write("\t \"" + objIDJson3 + "\":" + " " + "" + "" + schemaVersion + "" + ",\n"); } else { - fileWriter2 - .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + fileWriter2.write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); } fileWriter2.close(); @@ -4287,6 +4316,11 @@ else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { @SuppressWarnings("unchecked") public static void createAndPublishPolicy() { + if (!AdminTestUtil.isTargetEnvLTS()) { + // In case of 1.1.5 we don't have auto sync of certificates between Key manager cert store and IDA cert store + // So use the predefined certificate folder and partner key + return ; + } String token = kernelAuthLib.getTokenByRole(GlobalConstants.PARTNER); @@ -4425,40 +4459,62 @@ public static Certificate convertToCertificate(String certData) { return null; } } + + public static boolean isTargetEnvLTS() { - public static int getOtpExpTimeFromActuator() { - Response response = null; - int otpExpTime = 10; - org.json.JSONObject responseJson = null; - JSONArray responseArray = null; - String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); - try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + if (targetEnvVersion.isEmpty()) { - responseJson = new org.json.JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + Response response = null; + JSONObject responseJson = null; + String url = ApplnURI + propsKernel.getProperty("auditActuatorEndpoint"); + try { + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + GlobalMethods.reportResponse(url, response); - for (int i = 0, size = responseArray.length(); i < size; i++) { - org.json.JSONObject eachJson = responseArray.getJSONObject(i); - logger.info("eachJson is :" + eachJson.toString()); - if (eachJson.get("name").toString().contains( - "configService:https://github.com/mosip/mosip-config/application-default.properties")) { - - org.json.JSONObject otpExpiryTime = (org.json.JSONObject) eachJson - .getJSONObject(GlobalConstants.PROPERTIES).get("mosip.kernel.otp.expiry-time"); - String otpExpiryTimeVal = otpExpiryTime.getString(GlobalConstants.VALUE); - otpExpTime = Integer.parseInt(otpExpiryTimeVal); - break; - } - } + responseJson = new JSONObject(response.getBody().asString()); - return otpExpTime; - } catch (Exception e) { - logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); - return otpExpTime; + targetEnvVersion = responseJson.getJSONObject("build").getString("version"); + + } catch (Exception e) { + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); + } } + return targetEnvVersion.contains("1.2"); + } + + + private static String otpExpTime = ""; + public static int getOtpExpTimeFromActuator() { + if (otpExpTime.isEmpty()) { + Response response = null; + org.json.JSONObject responseJson = null; + JSONArray responseArray = null; + String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); + try { + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + GlobalMethods.reportResponse(url, response); + + responseJson = new org.json.JSONObject(response.getBody().asString()); + responseArray = responseJson.getJSONArray("propertySources"); + + for (int i = 0, size = responseArray.length(); i < size; i++) { + org.json.JSONObject eachJson = responseArray.getJSONObject(i); + logger.info("eachJson is :" + eachJson.toString()); + if (eachJson.get("name").toString().contains( + "configService:https://github.com/mosip/mosip-config/application-default.properties")) { + + org.json.JSONObject otpExpiryTime = (org.json.JSONObject) eachJson + .getJSONObject(GlobalConstants.PROPERTIES).get("mosip.kernel.otp.expiry-time"); + otpExpTime = otpExpiryTime.getString(GlobalConstants.VALUE); + break; + } + } + } catch (Exception e) { + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); + } + } + return Integer.parseInt(otpExpTime); } public static String getValueFromActuator(String section, String key) { @@ -4828,5 +4884,16 @@ public static void checkDbAndValidate(String timeStamp, String dbChecker) throws throw new AdminTestException("Failed at output validation"); Reporter.log(ReportUtil.getOutputValidationReport(objMap)); } + + public static String getPartnerIdFromPartnerURL(String partnerKeyURLSuffix) { + Pattern pattern = Pattern.compile("/(.*?)/"); + Matcher matcher = pattern.matcher(partnerKeyURLSuffix); + String substring = ""; + if (matcher.find()) { + substring = matcher.group(1); + } + System.out.println(substring); // substring + return substring; + } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java index dc042667128..b4ff03b752f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java @@ -41,11 +41,15 @@ public static String getOutputValidationReport(Map" + dto.getExpValue() + "\r\n" + " " + dto.getActualValue() + "\r\n" + " " + dto.getStatus() + "\r\n" + " \r\n"; } - else if (dto.getStatus().equals("WARNING")) { - htmlforReport = htmlforReport + " \r\n" + " " + dto.getFieldName() + "\r\n" - + " " + dto.getExpValue() + "\r\n" + " " + dto.getActualValue() - + "\r\n" + " " + dto.getStatus() + "\r\n" + " \r\n"; - } + // If it is warning basically we haven't compared or ignored the comparison. + // so no point in printing that content in the report. + /* + * else if (dto.getStatus().equals("WARNING")) { htmlforReport = htmlforReport + + * " \r\n" + " " + dto.getFieldName() + "\r\n" + " " + + * dto.getExpValue() + "\r\n" + " " + dto.getActualValue() + + * "\r\n" + " " + dto.getStatus() + + * "\r\n" + " \r\n"; } + */ } } htmlforReport = htmlforReport + ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index a450723068e..bf8e488abb8 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -207,12 +207,13 @@ protected void writeSuiteSummary() { writer.print(""); writer.print(""); writer.print(""); + writer.print(""); writer.print(""); writer.print(""); writer.print(""); writer.print(""); - writer.print(""); - writer.print(""); +// writer.print(""); +// writer.print(""); writer.print(GlobalConstants.TR); int testIndex = 0; @@ -236,13 +237,14 @@ protected void writeSuiteSummary() { buffer.setLength(0); writeTableData(buffer.append("") .append(Utils.escapeHtml(testResult.getTestName())).append("").toString()); + writeTableData(integerFormat.format(passedTests + skippedTests + failedTests), "num"); writeTableData(integerFormat.format(passedTests), "num"); writeTableData(integerFormat.format(skippedTests), (skippedTests > 0 ? GlobalConstants.NUMATTN : "num")); writeTableData(integerFormat.format(failedTests), (failedTests > 0 ? GlobalConstants.NUMATTN : "num")); writeTableData(decimalFormat.format(duration), "num"); - writeTableData(testResult.getIncludedGroups()); - writeTableData(testResult.getExcludedGroups()); +// writeTableData(testResult.getIncludedGroups()); +// writeTableData(testResult.getExcludedGroups()); writer.print(GlobalConstants.TR); @@ -258,6 +260,7 @@ protected void writeSuiteSummary() { if (testIndex > 1) { writer.print(""); writer.print(""); + writeTableHeader(integerFormat.format(totalPassedTests + totalSkippedTests + totalFailedTests), "num"); writeTableHeader(integerFormat.format(totalPassedTests), "num"); writeTableHeader(integerFormat.format(totalSkippedTests), (totalSkippedTests > 0 ? GlobalConstants.NUMATTN : "num")); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalConstants.java b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalConstants.java index cd1fe7f8958..f3e217c76c6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalConstants.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalConstants.java @@ -17,7 +17,10 @@ public class GlobalConstants { public static final String LANGCODE = "langcode"; public static final String FILTERS = "filters"; public static final String FULLNAME = "fullName"; + public static final String FIRST_NAME = "firstName"; + public static final String GENDER = "gender"; public static final String PROOFOFIDENTITY = "proofOfIdentity"; + public static final String PROOF_OF_ADDRESS = "proofOfAddress"; public static final String BIOVALUE = "bioValue"; public static final String BIOMETRICS = "biometrics"; public static final String SIMPLETYPE = "simpleType"; @@ -50,6 +53,7 @@ public class GlobalConstants { public static final String MOBILEID = "mobileid"; public static final String ESIGNET = "esignet"; public static final String APIKEY = "apiKey"; + public static final String PARTNER_APIKEY = "partnerApiKey"; public static final String PARTNERID = "partnerId"; public static final String REPORT_RESPONSE_PREFIX = "Actual Response Content: (EndPointUrl: "; public static final String REPORT_RESPONSE_SUFFIX = ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java index 618b9892360..3d05f70e3cd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java @@ -24,6 +24,11 @@ public class CertificateGenerationUtil extends AdminTestUtil { } public static void getThumbprints() { + if (!AdminTestUtil.isTargetEnvLTS()) { + // In case of 1.1.5 we don't have auto sync of certificates between Keymanager cert store and IDA cert store + // So use the predefined certificate folder and partnerkey + return ; + } String appId = properties.getProperty("appIdForCertificate"); getAndUploadIdaCertificate(appId, properties.getProperty("partnerrefId"), properties.getProperty("uploadPartnerurl")); getAndUploadIdaCertificate(appId, properties.getProperty("internalrefId"), properties.getProperty("uploadInternalurl")); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java index 612f947d1c7..e59d8a2ffb8 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java @@ -10,6 +10,7 @@ import io.mosip.testrig.apirig.admin.fw.util.AdminTestUtil; import io.mosip.testrig.apirig.authentication.fw.util.RestClient; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KeycloakUserManager; import io.restassured.response.Response; @@ -18,7 +19,8 @@ public class KeyCloakUserAndAPIKeyGeneration extends AdminTestUtil { static String partnerId = PartnerRegistration.partnerId; static String emailId = PartnerRegistration.emailId; - static String role = PartnerRegistration.partnerType; + static String role = AdminTestUtil.isTargetEnvLTS() ? PartnerRegistration.partnerType + : PartnerRegistration.role; static String policyGroup = PartnerRegistration.policyGroup; static String randomAbbreviation = generateRandomAlphabeticString(4).toUpperCase(); static String policyName = AdminTestUtil.policyName; @@ -28,10 +30,45 @@ public static String createKCUserAndGetAPIKey() { String mappingKey = submittingPartnerAndGetMappingKey(); approvePartnerAPIKey(mappingKey); return createAPIKey(); + } + + public static String createKCUserAndGetAPIKeyNonLTS() { + KeycloakUserManager.createKeyCloakUsers(partnerId, emailId, role); + String apiRequestId = submittingPartnerAndGetApiRequestId(); + approvePartnerAPIKeyNonLTS(apiRequestId); + return createAPIKeyNonLTS(); + } + + public static String submittingPartnerAndGetApiRequestId() { + String url = ApplnURI + "/v1/partnermanager/partners/"+partnerId+"/apikey/request"; + + String token = kernelAuthLib.getTokenByRole("partner"); + HashMap requestBody = new HashMap<>(); + + requestBody.put("policyName", policyName); + requestBody.put("useCaseDescription", "mapping Partner to policyName"); + + HashMap body = new HashMap<>(); + + body.put("id", GlobalConstants.STRING); + body.put(GlobalConstants.METADATA, new HashMap<>()); + body.put(GlobalConstants.REQUEST, requestBody); + body.put(GlobalConstants.REQUESTTIME, generateCurrentUTCTimeStamp()); + body.put(GlobalConstants.VERSION, GlobalConstants.STRING); + Response response = RestClient.patchRequestWithCookie(url, body, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + lOGGER.info(response); + JSONObject responseJson = new JSONObject(response.asString()); + lOGGER.info(responseJson); + JSONObject responseValue = (JSONObject) (responseJson.get("response")); + lOGGER.info(responseValue); + String apiRequestId = responseValue.getString("apiRequestId"); + lOGGER.info(apiRequestId); + return apiRequestId; } + public static String submittingPartnerAndGetMappingKey() { String url = ApplnURI + "/v1/partnermanager/partners/"+partnerId+"/policy/map"; @@ -62,6 +99,29 @@ public static String submittingPartnerAndGetMappingKey() { return mappingKey; } + public static void approvePartnerAPIKeyNonLTS(String apiRequestId){ + String url = ApplnURI + "/v1/partnermanager/partners/apikey/"+apiRequestId; + + String token = kernelAuthLib.getTokenByRole("partner"); + + HashMap requestBody = new HashMap<>(); + + requestBody.put("status", "Approved"); + + HashMap body = new HashMap<>(); + + body.put("id", GlobalConstants.STRING); + body.put(GlobalConstants.METADATA, new HashMap<>()); + body.put(GlobalConstants.REQUEST, requestBody); + body.put(GlobalConstants.REQUESTTIME, generateCurrentUTCTimeStamp()); + body.put(GlobalConstants.VERSION, GlobalConstants.STRING); + + Response response = RestClient.patchRequestWithCookie(url, body, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + lOGGER.info(response); + JSONObject responseJson = new JSONObject(response.asString()); + lOGGER.info(responseJson); + } + public static void approvePartnerAPIKey(String mappingKey){ String url = ApplnURI + "/v1/partnermanager/partners/policy/"+mappingKey; @@ -85,6 +145,27 @@ public static void approvePartnerAPIKey(String mappingKey){ lOGGER.info(responseJson); } + public static String createAPIKeyNonLTS(){ + String url = ApplnURI + "/v1/partnermanager/partners/"+partnerId+"/apikey/request"; + + String token = kernelAuthLib.getTokenByRole("partner"); + + Response response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + lOGGER.info(response); + JSONObject responseJson = new JSONObject(response.asString()); + lOGGER.info(responseJson); + + String apiKey = responseJson.getJSONArray("response").getJSONObject(0).getString(GlobalConstants.PARTNER_APIKEY); + + +// JSONObject responseValue = (JSONObject) (responseJson.get("response")); +// lOGGER.info(responseValue); +// String apiKey = responseValue.getString(GlobalConstants.PARTNER_APIKEY); +// lOGGER.info(apiKey); + + return apiKey; + } + public static String createAPIKey(){ String url = ApplnURI + "/v1/partnermanager/partners/"+partnerId+"/generate/apikey"; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java index 85199a7f19a..00643bb5691 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java @@ -25,6 +25,7 @@ public class MispPartnerAndLicenseKeyGeneration extends AdminTestUtil{ public static String mispOrganizationName = "mosip-" + timeStamp; public static String mispPartnerId = mispOrganizationName; public static String mispPartnerType = "Misp_Partner"; + public static String mispPartnerTypeNonLTS = "MISP_Partner"; static String getPartnerType = "MISP"; public static String getAndUploadCertificatesAndGenerateMispLicKey() { @@ -72,7 +73,10 @@ public static void mispPartnerGeneration() { requestBody.put("emailId", emailId); requestBody.put("organizationName", mispOrganizationName); requestBody.put(GlobalConstants.PARTNERID, mispPartnerId); - requestBody.put(GlobalConstants.PARTNERTYPE, mispPartnerType); + if (AdminTestUtil.isTargetEnvLTS()) + requestBody.put(GlobalConstants.PARTNERTYPE, mispPartnerType); + else + requestBody.put(GlobalConstants.PARTNERTYPE, mispPartnerTypeNonLTS); requestBody.put("policyGroup", policyGroup); HashMap body = new HashMap<>(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java index 123b0105fbf..8110fa9456a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java @@ -31,16 +31,28 @@ public class PartnerRegistration extends AdminTestUtil { public static String deviceOrganizationName = "mosip_deviceorg" + timeStamp; public static String ftmOrganizationName = "mosip_ftmorg" + timeStamp; public static String partnerId = organizationName; - public static String partnerType = "AUTH_PARTNER"; + public static String role = "AUTH_PARTNER"; + public static String partnerType = "Auth_Partner"; static String getPartnerType = "RELYING_PARTY"; public static String policyGroup = AdminTestUtil.policyGroup; public static String generateAndGetPartnerKeyUrl() { + if (!AdminTestUtil.isTargetEnvLTS()) { + // In case of 1.1.5 we don't have auto sync of certificates between Key manager cert store and IDA cert store + // So use the predefined certificate folder and partner key + partnerKeyUrl = ConfigManager.getPartnerUrlSuffix(); + partnerId = getPartnerIdFromPartnerURL(partnerKeyUrl); + return ConfigManager.getPartnerUrlSuffix(); + } + String apiKey = ""; ftmGeneration(); deviceGeneration(); getAndUploadCertificates(); - String apiKey = KeyCloakUserAndAPIKeyGeneration.createKCUserAndGetAPIKey(); + if (AdminTestUtil.isTargetEnvLTS()) + apiKey = KeyCloakUserAndAPIKeyGeneration.createKCUserAndGetAPIKey(); + else + apiKey = KeyCloakUserAndAPIKeyGeneration.createKCUserAndGetAPIKeyNonLTS(); String mispLicKey = MispPartnerAndLicenseKeyGeneration.getAndUploadCertificatesAndGenerateMispLicKey(); if (apiKey.isEmpty() || mispLicKey.isEmpty()) { @@ -363,6 +375,13 @@ public static void ftmGeneration() { } public static void deleteCertificates() { + if (!AdminTestUtil.isTargetEnvLTS()) { + // In case of 1.1.5 we don't have auto sync of certificates between Keymanager cert store and IDA cert store + // So use the predefined certificate folder and partnerkey + return ; + } + + if (localHostUrl == null) { localHostUrl = getLocalHostUrl(); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index 72e7dfd8e26..b2237157917 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -113,6 +113,11 @@ public class ConfigManager { private static String REPORT_EXPIRATION_IN_DAYS = "reportExpirationInDays"; private static String SCENARIOS_TO_BE_SKIPPED = "scenariosToSkip"; + + private static String PARTNER_URL_SUFFIX = "partnerUrlSuffix"; + + private static String partnerUrlSuffix; + private static String toSkippedList; private static String pms_client_secret; @@ -359,6 +364,10 @@ public static void init() { ? propsKernel.getProperty(SCENARIOS_TO_BE_SKIPPED) : System.getenv(SCENARIOS_TO_BE_SKIPPED); propsKernel.setProperty(SCENARIOS_TO_BE_SKIPPED, toSkippedList); + + partnerUrlSuffix = System.getenv(PARTNER_URL_SUFFIX) == null ? propsKernel.getProperty(PARTNER_URL_SUFFIX) + : System.getenv(PARTNER_URL_SUFFIX); + propsKernel.setProperty(PARTNER_URL_SUFFIX, partnerUrlSuffix); } @@ -372,6 +381,10 @@ public static boolean isInTobeSkippedList(String stringToFind) { } return false; } + + public static String getPartnerUrlSuffix() { + return partnerUrlSuffix; + } public static Boolean IseSignetDeployed() { return esignet_deployed.equalsIgnoreCase("yes"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java index ca84dae3f05..e252cde154d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java @@ -88,13 +88,24 @@ public String getTokenByRole(String role, String tokenType) idaCookie = kernelAuthLib.getAuthForIDA(); return idaCookie; case "idrepo": - if(!kernelCmnLib.isValidToken(idrepoCookie)) - idrepoCookie = kernelAuthLib.getAuthForIDREPO(); - return idrepoCookie; + if (AdminTestUtil.isTargetEnvLTS()) { + if(!kernelCmnLib.isValidToken(idrepoCookie)) + idrepoCookie = kernelAuthLib.getAuthForIDREPO(); + return idrepoCookie; + } + else { + if(!kernelCmnLib.isValidToken(regProCookie)) + regProCookie = kernelAuthLib.getAuthForRegProc(); + return regProCookie; + } case "regproc": if(!kernelCmnLib.isValidToken(regProcCookie)) regProcCookie = kernelAuthLib.getAuthForRegistrationProcessor(); return regProcCookie; + case "regpro": + if(!kernelCmnLib.isValidToken(regProCookie)) + regProCookie = kernelAuthLib.getAuthForRegProc(); + return regProCookie; case "admin": if(!kernelCmnLib.isValidToken(adminCookie)) adminCookie = kernelAuthLib.getAuthForAdmin(); @@ -146,9 +157,15 @@ public String getTokenByRole(String role, String tokenType) residentNewCookieKc = kernelAuthLib.getAuthForNewResidentKc(); return residentNewCookieKc; case "hotlist": - if(!kernelCmnLib.isValidToken(hotlistCookie)) - residentCookie = kernelAuthLib.getAuthForHotlist(); - return residentCookie; + if (AdminTestUtil.isTargetEnvLTS()) { + if(!kernelCmnLib.isValidToken(hotlistCookie)) + residentCookie = kernelAuthLib.getAuthForHotlist(); + return residentCookie; + }else { + if(!kernelCmnLib.isValidToken(regProCookie)) + regProCookie = kernelAuthLib.getAuthForRegProc(); + return regProCookie; + } case "globaladmin": if(!kernelCmnLib.isValidToken(zonemapCookie)) zonemapCookie = kernelAuthLib.getAuthForzoneMap(); @@ -435,6 +452,22 @@ public String getAuthForRegistrationProcessor() { return cookie; } + @SuppressWarnings("unchecked") + public String getAuthForRegProc() { + + JSONObject actualrequest = getRequestJson(authRequest); + JSONObject request=new JSONObject(); + request.put(GlobalConstants.APPID, "regproc"); + request.put(GlobalConstants.CLIENTID, "mosip-regproc-client"); + request.put(GlobalConstants.SECRETKEY, "abc123"); + actualrequest.put(GlobalConstants.REQUEST, request); + + Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + logger.info("Regproc Cookie is:: " + cookie); + return cookie; +} + @SuppressWarnings("unchecked") public String getAuthForIDA() { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java index 90251ad59d8..73cb80a4b43 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java @@ -151,7 +151,13 @@ public static void createKeyCloakUsers(String partnerId,String emailId, String u logger.info(response); logger.info(String.format(GlobalConstants.REPSONSE, response.getStatus(), response.getStatusInfo())); logger.info(response.getLocation()); - String userId = CreatedResponseUtil.getCreatedId(response); + String userId = ""; + if (!response.getStatusInfo().equals(Response.Status.CONFLICT)){ + userId = CreatedResponseUtil.getCreatedId(response); + } + else { + userId = getKeycloakUserID(needsToBeCreatedUser); + } logger.info(String.format(GlobalConstants.USERCREATEDWITHUSERID, userId)); CredentialRepresentation passwordCred = new CredentialRepresentation(); @@ -183,6 +189,20 @@ public static void createKeyCloakUsers(String partnerId,String emailId, String u } } + public static String getKeycloakUserID(String userName) { + Keycloak keycloakInstance = getKeycloakInstance(); + RealmResource realmResource = keycloakInstance.realm(ConfigManager.getIAMRealmId()); + UsersResource usersRessource = realmResource.users(); + + List usersFromDB = usersRessource.search(userName); + if (!usersFromDB.isEmpty()) { + return usersFromDB.get(0).getId(); + } else { + return ""; + } + + } + public static void removeKeyCloakUser(String partnerId) { List needsToBeRemovedUsers = List.of(partnerId); Keycloak keycloakInstance = getKeycloakInstance(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index b404720508b..5e698e56358 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -34,6 +34,7 @@ import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.global.utils.GlobalMethods; import io.mosip.testrig.apirig.kernel.util.CommonLibrary; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KernelAuthentication; import io.mosip.testrig.apirig.testrunner.MockSMTPListener; import io.mosip.testrig.apirig.testrunner.MosipTestRunner; @@ -66,6 +67,7 @@ public class BaseTestCase { public String idaCookie = null; public String idrepoCookie = null; public String regProcCookie = null; + public String regProCookie = null; public String regAdminCookie = null; public String registrationOfficerCookie = null; public String regSupervisorCookie = null; @@ -511,6 +513,12 @@ public static List getLanguageList() { } public static List getSupportedIdTypesValueFromActuator() { + + // TODO Remove this work around after the IDA actuator works + if (!AdminTestUtil.isTargetEnvLTS()) { + supportedIdType.add("UIN"); + supportedIdType.add("VID"); + } if (!supportedIdType.isEmpty()) { return supportedIdType; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 1f8ad95dcea..1dffcd89ef6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -67,11 +67,11 @@ public static void main(String[] arg) { ConfigManager.init(); BaseTestCase.suiteSetup(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); - HealthChecker healthcheck = new HealthChecker(); - healthcheck.setCurrentRunningModule(BaseTestCase.currentModule); - Thread trigger = new Thread(healthcheck); - trigger.start(); - +// HealthChecker healthcheck = new HealthChecker(); +// healthcheck.setCurrentRunningModule(BaseTestCase.currentModule); +// Thread trigger = new Thread(healthcheck); +// trigger.start(); + KeycloakUserManager.removeUser(); KeycloakUserManager.createUsers(); String partnerKeyURL = ""; @@ -118,7 +118,7 @@ public static void main(String[] arg) { MockSMTPListener.bTerminate = true; - HealthChecker.bTerminate = true; +// HealthChecker.bTerminate = true; System.exit(0); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java index 42d27cc0a2a..ef5674f708f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java @@ -84,6 +84,20 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { + throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); + } + } + + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { + throw new SkipException("Idtype VID is not supported. Hence skipping the testcase"); + } + } + if (testCaseDTO.getEndPoint().contains("$PartnerKeyURL$")) { testCaseDTO.setEndPoint( testCaseDTO.getEndPoint().replace("$PartnerKeyURL$", PartnerRegistration.partnerKeyUrl)); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java index a9a15733c61..827c708bd06 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java @@ -82,6 +82,21 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { + throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); + } + } + + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { + throw new SkipException("Idtype VID is not supported. Hence skipping the testcase"); + } + } + if (testCaseDTO.getEndPoint().contains("$partnerKeyURL$")) { testCaseDTO.setEndPoint( testCaseDTO.getEndPoint().replace("$partnerKeyURL$", PartnerRegistration.partnerKeyUrl)); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java index 4c201ec0653..62ec15b616d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java @@ -81,6 +81,21 @@ public void test(TestCaseDTO testCaseDTO) if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { + throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); + } + } + + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { + throw new SkipException("Idtype VID is not supported. Hence skipping the testcase"); + } + } + if (testCaseDTO.getEndPoint().contains("$PartnerKeyURL$")) { testCaseDTO.setEndPoint( testCaseDTO.getEndPoint().replace("$PartnerKeyURL$", PartnerRegistration.partnerKeyUrl)); @@ -93,6 +108,15 @@ public void test(TestCaseDTO testCaseDTO) if (input.contains("$PRIMARYLANG$")) input = input.replace("$PRIMARYLANG$", BaseTestCase.languageList.get(0)); + + if (input.contains("$NAMEPRIMARYLANG$")) { + String name = ""; + if (AdminTestUtil.isTargetEnvLTS()) + name = propsMap.getProperty("fullName"); + else + name = propsMap.getProperty("firstName"); + input = input.replace("$NAMEPRIMARYLANG$", name + BaseTestCase.languageList.get(0)); + } String[] templateFields = testCaseDTO.getTemplateFields(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java index 7893ece7829..c2d5b9d8bab 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java @@ -84,6 +84,21 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { + throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); + } + } + + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { + throw new SkipException("Idtype VID is not supported. Hence skipping the testcase"); + } + } + JSONObject request = new JSONObject(testCaseDTO.getInput()); String identityRequest = null; String identityRequestTemplate = null; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java index f7b54209282..e12815875eb 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java @@ -106,8 +106,12 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); - if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) - throw new AdminTestException("Failed at otp output validation"); + if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { + if (otpResponse.asString().contains("IDA-OTA-001")) + throw new AdminTestException("Exceeded number of OTP requests in a given time, Increase otp.request.flooding.max-count"); + else + throw new AdminTestException("Failed at otp output validation"); + } JSONObject reqvOtp = new JSONObject(testCaseDTO.getInput()); JSONObject reqvtOtp = (JSONObject) reqvOtp.get(GlobalConstants.SENDOTP); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java index 68bda52aab0..d053f64b222 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java @@ -81,6 +81,20 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { + throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); + } + } + + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { + throw new SkipException("Idtype VID is not supported. Hence skipping the testcase"); + } + } JSONObject input = new JSONObject(testCaseDTO.getInput()); String individualId = null; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java index fcfd3549d5f..f028f4f3eb6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java @@ -81,6 +81,20 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { + throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); + } + } + + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { + if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") + && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { + throw new SkipException("Idtype VID is not supported. Hence skipping the testcase"); + } + } JSONObject input = new JSONObject(testCaseDTO.getInput()); String individualId = null; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java index 8841d3f3457..fdee42a572b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java @@ -94,8 +94,12 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); - if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) - throw new AdminTestException("Failed at otp output validation"); + if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { + if (otpResponse.asString().contains("IDA-OTA-001")) + throw new AdminTestException("Exceeded number of OTP requests in a given time, Increase otp.request.flooding.max-count"); + else + throw new AdminTestException("Failed at otp output validation"); + } Response response = patchRequestWithCookieAndHeader(ApplnURI + testCaseDTO.getEndPoint(), getJsonFromTemplate(req.toString(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java index 07ab7d7fa8a..63169766d1d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java @@ -27,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.kernel.util.ConfigManager; +import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -77,6 +78,9 @@ public void test(TestCaseDTO testCaseDTO) if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + if ((!AdminTestUtil.isTargetEnvLTS()) && BaseTestCase.currentModule.equals("auth") && testCaseName.startsWith("auth_GenerateVID_")) { + throw new SkipException("Generating VID using IdRepo API on Pre-LTS. Hence skipping this test case"); + } testCaseName = isTestCaseValidForExecution(testCaseDTO); JSONObject req = new JSONObject(testCaseDTO.getInput()); auditLogCheck = testCaseDTO.isAuditLogCheck(); @@ -142,8 +146,13 @@ public void test(TestCaseDTO testCaseDTO) otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); - if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) - throw new AdminTestException("Failed at otp output validation"); + if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { + if (otpResponse.asString().contains("IDA-OTA-001")) + throw new AdminTestException("Exceeded number of OTP requests in a given time, Increase otp.request.flooding.max-count"); + else + throw new AdminTestException("Failed at otp output validation"); + } + } else { throw new AdminTestException("Invalid otp response"); @@ -200,9 +209,12 @@ public void setResultTestName(ITestResult result) { public void waittime() { try { if ((!testCaseName.contains(GlobalConstants.ESIGNET_)) && (!testCaseName.contains("Resident_CheckAidStatus"))) { - logger.info("waiting for" + properties.getProperty("Delaytime") + long delayTime = Long.parseLong(properties.getProperty("Delaytime")); + if (!AdminTestUtil.isTargetEnvLTS()) + delayTime = Long.parseLong(properties.getProperty("uinGenDelayTime")) * Long.parseLong(properties.getProperty("uinGenMaxLoopCount")); + logger.info("waiting for " + delayTime + " mili secs after VID Generation In RESIDENT SERVICES"); - Thread.sleep(Long.parseLong(properties.getProperty("Delaytime"))); + Thread.sleep(delayTime); } } catch (Exception e) { logger.error("Exception : " + e.getMessage()); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java index c90f13cef45..d63c0294fef 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java @@ -115,8 +115,12 @@ else if(testCaseName.contains("ESignet_WalletBinding")) { .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); - if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) - throw new AdminTestException("Failed at otp output validation"); + if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { + if (otpResponse.asString().contains("IDA-OTA-001")) + throw new AdminTestException("Exceeded number of OTP requests in a given time, Increase otp.request.flooding.max-count"); + else + throw new AdminTestException("Failed at otp output validation"); + } if(testCaseName.contains("_eotp")) { try { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java index 6dd3f42d7db..c0503074672 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java @@ -136,8 +136,12 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); - if (!OutputValidationUtil.publishOutputResult(ouputValid)) - throw new AdminTestException("Failed at output validation"); + if (!OutputValidationUtil.publishOutputResult(ouputValid)) { + if (response.asString().contains("IDA-OTA-001")) + throw new AdminTestException("Exceeded number of OTP requests in a given time, Increase otp.request.flooding.max-count"); + else + throw new AdminTestException("Failed at otp output validation"); + } } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java index 101f07f07b9..1675a5437d9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java @@ -80,6 +80,9 @@ public void test(TestCaseDTO testCaseDTO) if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } + if (AdminTestUtil.isTargetEnvLTS() && BaseTestCase.currentModule.equals("auth") && testCaseName.startsWith("auth_GenerateVID_")) { + throw new SkipException("Generating VID using resident API on LTS. Hence skipping this test case"); + } testCaseName = isTestCaseValidForExecution(testCaseDTO); String[] templateFields = testCaseDTO.getTemplateFields(); String inputJson = ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java index f5d092df301..ae15a726516 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java @@ -76,7 +76,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (BaseTestCase.languageList.size() == 2) { jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"FR\" }", ""); jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"Female\" }", ""); - jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"Mrs Madhu.GN\" }", ""); + jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"Mrs Lisa.GN\" }", ""); jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"Line1\" }", ""); jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"Line2\" }", ""); jsonInput = jsonInput.replace(", { \"language\": \"$3RDLANG$\", \"value\": \"Line3\" }", ""); @@ -88,7 +88,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ", { \"language\": \"$2NDLANG$\", \"value\": \"Female\" }, { \"language\": \"$3RDLANG$\", \"value\": \"Female\" }", ""); jsonInput = jsonInput.replace( - ", { \"language\": \"$2NDLANG$\", \"value\": \"Mrs Madhu.GN\" }, { \"language\": \"$3RDLANG$\", \"value\": \"Mrs Madhu.GN\" }", + ", { \"language\": \"$2NDLANG$\", \"value\": \"Mrs Lisa.GN\" }, { \"language\": \"$3RDLANG$\", \"value\": \"Mrs Lisa.GN\" }", ""); jsonInput = jsonInput.replace( ", { \"language\": \"$2NDLANG$\", \"value\": \"Line1\" }, { \"language\": \"$3RDLANG$\", \"value\": \"Line1\" }", diff --git a/automationtests/src/main/resources/config/AuthPolicy2.json b/automationtests/src/main/resources/config/AuthPolicy2.json index 54407f74da1..b2cb56a8975 100644 --- a/automationtests/src/main/resources/config/AuthPolicy2.json +++ b/automationtests/src/main/resources/config/AuthPolicy2.json @@ -36,10 +36,6 @@ "mandatory": false } ], - "kycLanguages": [ - "ara", - "eng" - ], "allowedKycAttributes": [ { "attributeName": "fullName" diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index cc3674022e8..5c330c757cf 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -106,40 +106,44 @@ mosip_pms_app_id=partner partner_password=mosip123 partner_userName=111997 partner_user_password=mosip123 -mosip_pms_client_id=mosip-pms-client -mosip_pms_client_secret=Tkx3jw9INusggEDW +mosip_pms_client_id=mosip-partner-client +mosip_pms_client_secret=abc123 policytest_password=mosip123 policytest_userName=111998 #RESIDENT & IDA mosip_resident_app_id=resident mosip_resident_client_id=mosip-resident-client -mosip_resident_client_secret=UGq78khkAst6fjbn +mosip_resident_client_secret=abc123 #IDREPO mosip_idrepo_app_id=idrepo -mosip_idrepo_client_id=mosip-idrepo-client -mosip_idrepo_client_secret=wJ21F8gXzdy2RM9q +mosip_idrepo_client_id=mosip-resident-client +mosip_idrepo_client_secret=abc123 #admin mosip_admin_app_id=admin admin_password=mosip123 admin_userName=220005 mosip_admin_client_id=mosip-admin-client -mosip_admin_client_secret=7Vvj405Z5a35eAod +mosip_admin_client_secret=xyz123 #admin admin_zone_password=mosip123 admin_zone_userName=globaladmin mosip_regclient_app_id=registrationclient mosip_reg_client_id=mosip-reg-client -mosip_reg_client_secret=SGqovDBMh7McnAxw +mosip_reg_client_secret=abc123 +#admin +mosip_regprocclient_app_id=regproc +mosip_regproc_client_id=mosip-regproc-client +mosip_regproc_client_secret=abc123 #mparter_mobile mpartner_default_mobile_client_id=mpartner-default-mobile -mpartner_default_mobile_secret=Gif10hl5sFH6WCUi +mpartner_default_mobile_secret=3adc8ff6-29a1-4149-9193-21752eb2f07a #This credentials are used to execute auth demo service AuthClientID=mosip-resident-client -AuthClientSecret=UGq78khkAst6fjbn +AuthClientSecret=abc123 AuthAppID=resident mosip_hotlist_app_id=hotlist mosip_hotlist_client_id=mosip-hotlist-client @@ -154,11 +158,11 @@ roles.111995=PARTNER_ADMIN,default-roles-mosip keycloak_UserName = admin -keycloak_Password = oY6ijJuIL8 +keycloak_Password = admin -keycloak-external-url=https://iam.dev3.mosip.net -mosip_testrig_client_id=mosip-testrig-client -mosip_testrig_client_secret=aOCfcQC2dYm2Iotg +keycloak-external-url=https://qa-115.mosip.net/keycloak +mosip_testrig_client_id=mosip-partner-client +mosip_testrig_client_secret=abc123 keycloak-realm-id=mosip iam-users-to-create=111997,111998,220005,111992,globaladmin @@ -176,14 +180,14 @@ dialect=org.hibernate.dialect.PostgreSQLDialect show_sql=true current_session_context_class=thread #audit details -audit_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_audit +audit_url=jdbc:postgresql://qa-115.mosip.net:5432/mosip_audit audit_username=postgres audit_password=rLqRHeY4C5 audit_default_schema=audit #ida-partner details DB_PORT= installation-domain= -partner_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_ida +partner_url=jdbc:postgresql://qa-115.mosip.net:5432/mosip_ida partner_username=postgres partner_password=rLqRHeY4C5 partner_default_schema=partner @@ -237,6 +241,7 @@ actuatorIDAEndpoint=/idauthentication/v1/actuator/env actuatorRegprocEndpoint=/registrationprocessor/v1/registrationtransaction/actuator/env actuatorEsignetEndpoint=/v1/esignet/actuator/env tokenEndpoint=/v1/esignet/oauth/token +auditActuatorEndpoint=/v1/auditmanager/actuator/info validateBindingEndpoint=ida-binding #To run in Docker @@ -254,4 +259,7 @@ eSignetDeployed=yes # ---- Add scenarios to skip from automation and server side ------------------------------------- # supported values "S-scnearioNumber" for server side and "A-scnearioNumber" for automation -scenariosToSkip= \ No newline at end of file +scenariosToSkip= + + +partnerUrlSuffix=oYf63Lax0DY2QkYMRHnrmDqhmO3RMWQagwm0ftgLlkuin1KOND/666/576732 \ No newline at end of file diff --git a/automationtests/src/main/resources/config/valueMapping.properties b/automationtests/src/main/resources/config/valueMapping.properties index 685fc13591c..a2e9de58b37 100644 --- a/automationtests/src/main/resources/config/valueMapping.properties +++ b/automationtests/src/main/resources/config/valueMapping.properties @@ -1,8 +1,18 @@ # common properties residenceStatus=NFR fullName=TEST_FULLNAME +firstName=TEST_FIRSTNAME dateOfBirth=1996/01/01 gender=MLE +pobCountry=POB_COUNTRY +pobProvince=POB_PROVINCE +pobCity=POB_CITY +bloodType=BLOOD_TYPE +permanentCountry=PERMANENT_COUNTRY +permanentAddressLine1=PERMANENT_ADDRESS_LINE_1 +presentAddressLine1=PRESENT_ADDRESS_LINE_1 +modeOfClaim=MODE_OF_CLAIM +presentCountry=PRESENT_COUNTRY addressLine1=TEST_ADDRESSLINE1 addressLine2=TEST_ADDRESSLINE2 addressLine3=TEST_ADDRESSLINE3 @@ -10,7 +20,8 @@ postalCode=14022 phone=8249742850 email=test@mosip.net region=TEST_REGION -fullName1=Madhu.GN +fullName1=Lisa.GN +firstName1=Lisa.GN province=TEST_PROVINCE city=TEST_CITY zone=TEST_ZONE diff --git a/automationtests/src/main/resources/ida/CreateVID/CreateVid.yml b/automationtests/src/main/resources/ida/CreateVID/CreateVid.yml new file mode 100644 index 00000000000..82c7a8016fa --- /dev/null +++ b/automationtests/src/main/resources/ida/CreateVID/CreateVid.yml @@ -0,0 +1,68 @@ +CreateVID: + auth_GenerateVID_All_Valid_Smoke_Perpetual_sid: + endPoint: /idrepository/v1/vid + role: idrepo + restMethod: post + inputTemplate: ida/CreateVID/createVid + outputTemplate: ida/CreateVID/createVidResult + input: '{ + "vidType": "Perpetual", + "UIN": "$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", + "version": "v1", + "id": "mosip.vid.create", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "vidStatus":"ACTIVE" +}' + + auth_GenerateVID_to_revoke_Perpetual_sid: + endPoint: /idrepository/v1/vid + role: idrepo + restMethod: post + inputTemplate: ida/CreateVID/createVid + outputTemplate: ida/CreateVID/createVidResult + input: '{ + "vidType": "Perpetual", + "UIN": "$ID:AddIdentity_create_vid_using_uin_for_revoke_smoke_Pos_UIN$", + "version": "v1", + "id": "mosip.vid.create", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "vidStatus":"ACTIVE" +}' + + auth_GenerateVID_to_test_hotlist_Perpetual_sid: + endPoint: /idrepository/v1/vid + role: idrepo + restMethod: post + inputTemplate: ida/CreateVID/createVid + outputTemplate: ida/CreateVID/createVidResult + input: '{ + "vidType": "Perpetual", + "UIN": "$ID:AddIdentity_for_hotlist_id_service_Pos_UIN$", + "version": "v1", + "id": "mosip.vid.create", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "vidStatus":"ACTIVE" +}' + + auth_GenerateVID_All_Valid_Smoke_Temp_VID_sid: + endPoint: /idrepository/v1/vid + role: idrepo + restMethod: post + inputTemplate: ida/CreateVID/createVid + outputTemplate: ida/CreateVID/createVidResult + input: '{ + "vidType": "Temporary", + "UIN": "$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", + "version": "v1", + "id": "mosip.vid.create", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "vidStatus":"ACTIVE" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/CreateVID/createVid.hbs b/automationtests/src/main/resources/ida/CreateVID/createVid.hbs new file mode 100644 index 00000000000..b0dfb2cbfd8 --- /dev/null +++ b/automationtests/src/main/resources/ida/CreateVID/createVid.hbs @@ -0,0 +1,11 @@ + +{ + "id": "{{id}}", + "metadata": {}, + "request": { + "UIN": "{{UIN}}", + "vidType": "{{vidType}}" + }, + "requesttime": "{{requesttime}}", + "version": "{{version}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs b/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs new file mode 100644 index 00000000000..57d4400e238 --- /dev/null +++ b/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs @@ -0,0 +1,13 @@ +{ + "id": "$IGNORE$", + "version": "$IGNORE$", + "responsetime": "$IGNORE$", + "metadata": null, + "response": { + "vidStatus": "{{vidStatus}}", + "restoredVid": null, + "UIN": null, + "VID": "$IGNORE$" + }, + "errors": [] +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index 0a8497f0937..149fc731b68 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -319,7 +319,7 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data gender in eng did not match", + "errorMessage": "$IGNORE$", "actionMessage": "Please re-enter your gender in eng" } ], @@ -345,7 +345,7 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data gender in eng did not match", + "errorMessage": "$IGNORE$", "actionMessage": "Please re-enter your gender in eng" } ], @@ -361,7 +361,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "FR" + "value": "$NAMEPRIMARYLANG$" } ], "timestamp": "$TIMESTAMP$", @@ -380,7 +380,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "Madhu.GN" + "value": "Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -399,7 +399,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss Madhu.GN" + "value": "Miss Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -418,7 +418,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mr Madhu.GN" + "value": "Mr Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -437,7 +437,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "Madhu.GN" + "value": "Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -456,7 +456,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss. Madhu.GN" + "value": "Miss. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -475,7 +475,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "MISS. Madhu.GN" + "value": "MISS. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -513,7 +513,7 @@ DemoAuthNew: "name": [ { "language": "$PRIMARYLANG$", - "value": "FR" + "value": "$NAMEPRIMARYLANG$" } ], "timestamp": "$TIMESTAMP$", @@ -542,7 +542,7 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data name in eng did not match", + "errorMessage": "$IGNORE$", "actionMessage": "Please re-enter your name in eng" } ], @@ -568,7 +568,7 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data name in eng did not match", + "errorMessage": "$IGNORE$", "actionMessage": "Please re-enter your name in eng" } ], diff --git a/automationtests/src/main/resources/ida/DemoAuthOld/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuthOld/DemoAuth.yml index f58809138b3..fe0e98991d3 100644 --- a/automationtests/src/main/resources/ida/DemoAuthOld/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuthOld/DemoAuth.yml @@ -399,7 +399,7 @@ DemoAuth: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss Madhu.GN" + "value": "Miss Lisa.GN" } ], "identityRequestTemplate": "ida/DemoAuth/DemoIdentityEncryptName" @@ -426,7 +426,7 @@ DemoAuth: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mr Madhu.GN" + "value": "Mr Lisa.GN" } ], "identityRequestTemplate": "ida/DemoAuth/DemoIdentityEncryptName" @@ -453,7 +453,7 @@ DemoAuth: "name": [ { "language": "$PRIMARYLANG$", - "value": "Madhu.GN" + "value": "Lisa.GN" } ], "identityRequestTemplate": "ida/DemoAuth/DemoIdentityEncryptName" @@ -480,7 +480,7 @@ DemoAuth: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss. Madhu.GN" + "value": "Miss. Lisa.GN" } ], "identityRequestTemplate": "ida/DemoAuth/DemoIdentityEncryptName" @@ -507,7 +507,7 @@ DemoAuth: "name": [ { "language": "$PRIMARYLANG$", - "value": "MISS. Madhu.GN" + "value": "MISS. Lisa.GN" } ], "identityRequestTemplate": "ida/DemoAuth/DemoIdentityEncryptName" diff --git a/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml b/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml index 526a1386ca9..1e345355686 100644 --- a/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml +++ b/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml @@ -359,7 +359,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mrs Madhu.GN" + "value": "Mrs Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -447,7 +447,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Madhu.GN" + "value": "Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -466,7 +466,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss Madhu.GN" + "value": "Miss Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -485,7 +485,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mr Madhu.GN" + "value": "Mr Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -504,7 +504,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mrs Madhu.GN" + "value": "Mrs Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -523,7 +523,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss. Madhu.GN" + "value": "Miss. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -542,7 +542,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "MISS. Madhu.GN" + "value": "MISS. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", diff --git a/automationtests/src/main/resources/ida/EkycDemoOld/EkycDemo.yml b/automationtests/src/main/resources/ida/EkycDemoOld/EkycDemo.yml index 28afeecdc61..13cc628eddc 100644 --- a/automationtests/src/main/resources/ida/EkycDemoOld/EkycDemo.yml +++ b/automationtests/src/main/resources/ida/EkycDemoOld/EkycDemo.yml @@ -374,7 +374,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mrs Madhu.GN" + "value": "Mrs Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" @@ -401,7 +401,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mrs Madhu.GN" + "value": "Mrs Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" @@ -521,7 +521,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss Madhu.GN" + "value": "Miss Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" @@ -548,7 +548,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mr Madhu.GN" + "value": "Mr Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" @@ -575,7 +575,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Mrs Madhu.GN" + "value": "Mrs Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" @@ -602,7 +602,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss. Madhu.GN" + "value": "Miss. Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" @@ -629,7 +629,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "MISS. Madhu.GN" + "value": "MISS. Lisa.GN" } ], "identityRequestTemplate": "ida/EkycDemo/DemoIdentityEncryptName" diff --git a/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml b/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml index db599d18b0c..80133887b44 100644 --- a/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml +++ b/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml @@ -10,15 +10,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "ACTIVATED", - "phone": "9876543210", "dateOfBirth": "1970/07/08", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FR" - } - ], "version": "v1", "sendOtp":{ "transactionID": "$TRANSACTIONID$", @@ -49,15 +42,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_Positive_EKYC_smoke_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "ACTIVATED", - "phone": "7019858531", "dateOfBirth": "1970/07/08", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FR" - } - ], "version": "v1" }' output: '{ @@ -74,15 +60,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_Positive_valid_smoke_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "ACTIVATED", - "phone": "7019858531", "dateOfBirth": "1970/07/08", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FRA" - } - ], "version": "v1" }' output: '{ @@ -99,15 +78,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "ACTIVATED", - "phone": "7019858531", "dateOfBirth": "1980/08/10", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FR" - } - ], "version": "v1" }' output: '{ @@ -124,15 +96,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_Deactivate_and_auth_smoke_Pos_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "DEACTIVATED", - "phone": "7019858531", "dateOfBirth": "1970/07/08", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FR" - } - ], "version": "v1" }' output: '{ @@ -149,15 +114,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_Positive_TRE_smoke_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "DEACTIVATED", - "phone": "7019858531", "dateOfBirth": "1970/07/08", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FR" - } - ], "version": "v1" }' output: '{ @@ -174,15 +132,8 @@ UpdateIdentity: "UIN":"$ID:AddIdentity_Positive_TRE_smoke_UIN$", "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "status": "ACTIVATED", - "phone": "7019858531", "dateOfBirth": "1970/07/08", "requesttime": "$TIMESTAMP$", - "fullName": [ - { - "language": "$PRIMARYLANG$", - "value": "FR" - } - ], "version": "v1" }' output: '{ diff --git a/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentity.hbs b/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentity.hbs index 1366c87979f..39bb975d1ff 100644 --- a/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentity.hbs +++ b/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentity.hbs @@ -6,18 +6,8 @@ "identity": { "IDSchemaVersion": $SCHEMAVERSION$, "email": "{{email}}", - "phone": "{{phone}}", "dateOfBirth": "{{dateOfBirth}}", - "UIN": "{{UIN}}", - "fullName": [ - {{#each fullName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] + "UIN": "{{UIN}}" } }, "requesttime": "{{requesttime}}", diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index 9583c760b6b..5e672409ea5 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -19,6 +19,13 @@ + + + + + + + Date: Fri, 28 Jul 2023 13:21:27 +0530 Subject: [PATCH 002/204] MOSIP-28585 --- .../apirig/admin/fw/util/AdminTestUtil.java | 2 +- .../main/resources/ida/DemoAuth/DemoAuth.yml | 18 +++++------ .../main/resources/ida/EkycDemo/EkycDemo.yml | 30 +++++++++---------- .../ida/UpdateIdentity/UpdateIdentity.yml | 2 +- 4 files changed, 26 insertions(+), 26 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 48b605457da..154205b1cee 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3782,7 +3782,7 @@ public static String modifySchemaGenerateHbs() { public static String modifySchemaGenerateHbs(boolean regenerateHbs) { String ja3 = ""; - if (identityHbs != null && regenerateHbs) { + if (identityHbs != null && !regenerateHbs) { return identityHbs; } StringBuffer everything = new StringBuffer(""); diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index 149fc731b68..20433041826 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -153,7 +153,7 @@ DemoAuthNew: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", + "value": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", "key": "emailId" }' output: '{ @@ -213,7 +213,7 @@ DemoAuthNew: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", + "value": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", "key": "emailId" }' output: '{ @@ -398,7 +398,7 @@ DemoAuthNew: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Miss Lisa.GN" } ], @@ -417,7 +417,7 @@ DemoAuthNew: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Mr Lisa.GN" } ], @@ -455,7 +455,7 @@ DemoAuthNew: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Miss. Lisa.GN" } ], @@ -474,7 +474,7 @@ DemoAuthNew: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "MISS. Lisa.GN" } ], @@ -493,8 +493,8 @@ DemoAuthNew: input: '{ "name": [ { - "language": "$PRIMARYLANG$", - "value": "Miss Madhu GN" + "language": "eng", + "value": "Miss Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -596,7 +596,7 @@ DemoAuthNew: inputTemplate: ida/DemoAuth/DemoAuth outputTemplate: ida/DemoAuth/DemoAuthResult input: '{ - "value": "51", + "value": "41", "key": "age", "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$" diff --git a/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml b/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml index 1e345355686..bab44f66cf1 100644 --- a/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml +++ b/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml @@ -23,7 +23,7 @@ EkycDemo: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "1970/07/08", + "value": "1980/08/10", "key": "dob" }' output: '{ @@ -192,7 +192,7 @@ EkycDemo: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", + "value": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", "key": "emailId" }' output: '{ @@ -358,7 +358,7 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Mrs Lisa.GN" } ], @@ -377,8 +377,8 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", - "value": "FR" + "language": "eng", + "value": "Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -465,7 +465,7 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Miss Lisa.GN" } ], @@ -484,7 +484,7 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Mr Lisa.GN" } ], @@ -503,7 +503,7 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Mrs Lisa.GN" } ], @@ -522,7 +522,7 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "Miss. Lisa.GN" } ], @@ -541,7 +541,7 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", + "language": "eng", "value": "MISS. Lisa.GN" } ], @@ -560,8 +560,8 @@ EkycDemo: input: '{ "name": [ { - "language": "$PRIMARYLANG$", - "value": "Miss Madhu GN" + "language": "eng", + "value": "Miss Lisa GN" } ], "timestamp": "$TIMESTAMP$", @@ -580,7 +580,7 @@ EkycDemo: "name": [ { "language": "$PRIMARYLANG$", - "value": "Miss Madhu GN" + "value": "Miss Lisa GN" } ], "timestamp": "$TIMESTAMP$", @@ -621,7 +621,7 @@ EkycDemo: inputTemplate: ida/EkycDemo/EkycDemo outputTemplate: ida/EkycDemo/EkycDemoResult input: '{ - "value": "51", + "value": "41", "key": "age", "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$" @@ -789,7 +789,7 @@ EkycDemo: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "1970/07/08", + "value": "1980/08/10", "key": "dob" }' output: '{ diff --git a/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml b/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml index 80133887b44..69ec50b9811 100644 --- a/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml +++ b/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml @@ -76,7 +76,7 @@ UpdateIdentity: input: '{ "registrationId":"$RID$", "UIN":"$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", - "email": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", + "email": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", "status": "ACTIVATED", "dateOfBirth": "1980/08/10", "requesttime": "$TIMESTAMP$", From 121bea36b6f421b2fd89c1c080bc62ec53ba9a64 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Wed, 2 Aug 2023 18:10:59 +0530 Subject: [PATCH 003/204] logging add --- .../java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java | 1 + 1 file changed, 1 insertion(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index 72e7dfd8e26..aed5b974369 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -365,6 +365,7 @@ public static void init() { public static boolean isInTobeSkippedList(String stringToFind) { synchronized (toSkippedList) { List toBeSkippedLsit = Arrays.asList(toSkippedList.split(",")); + LOGGER.info("toSkippedList: " + toSkippedList + ", toBeSkippedLsit : "+ toBeSkippedLsit + ", stringToFind : "+ stringToFind ); for (String string : toBeSkippedLsit) { if (string.equalsIgnoreCase(stringToFind)) return true; From 2b9b09388edb0c7b8a5e0febfa7ab53d0deabde9 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 2 Aug 2023 19:34:21 +0530 Subject: [PATCH 004/204] resolved esignet bio auth issue --- .../demo/service/controller/Encrypt.java | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java index 7e79fddf85c..4674b0c6448 100644 --- a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java +++ b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java @@ -257,11 +257,22 @@ public static RequestWrapper createRequest(T t) { @PostMapping(path = "/splitEncryptedData", produces = MediaType.APPLICATION_JSON_VALUE) public SplittedEncryptedData splitEncryptedData(@RequestBody String data) { + boolean encryptedDataHasVersion = env.getProperty("encryptedDataHasVersion", boolean.class, false); byte[] dataBytes = CryptoUtil.decodeURLSafeBase64(data); byte[][] splits = splitAtFirstOccurance(dataBytes, keySplitter.getBytes()); byte[] thumbPrintAndSessionKey = splits[0]; - byte[] thumbPrint = Arrays.copyOfRange(thumbPrintAndSessionKey, 6, 38);//Skip the 6 bytes version and take 32 bytes - byte[] sessionKey = Arrays.copyOfRange(thumbPrintAndSessionKey, 38, thumbPrintAndSessionKey.length); + byte[] sessionKey; + byte[] thumbPrint; + + if(encryptedDataHasVersion) { + thumbPrint = Arrays.copyOfRange(thumbPrintAndSessionKey, 6, 38);//Skip the 6 bytes version and take 32 bytes + sessionKey = Arrays.copyOfRange(thumbPrintAndSessionKey, 38, thumbPrintAndSessionKey.length); + } + else { + thumbPrint = Arrays.copyOfRange(thumbPrintAndSessionKey, 0, 32); + sessionKey = Arrays.copyOfRange(thumbPrintAndSessionKey, 32, thumbPrintAndSessionKey.length); + } + byte[] encryptedData = splits[1]; return new SplittedEncryptedData(CryptoUtil.encodeToURLSafeBase64(sessionKey), CryptoUtil.encodeToURLSafeBase64(encryptedData), digestAsPlainText(thumbPrint)); } From bc7338e0f7131a84dff22c58d7b6e2b6a8fe7b51 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 3 Aug 2023 12:16:23 +0530 Subject: [PATCH 005/204] MOSIP-24680 --- .../apirig/admin/fw/util/AdminTestUtil.java | 54 +++++++++++++++++++ .../apirig/customReport/EmailableReport.java | 8 ++- 2 files changed, 61 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 928c853049d..a1c902ca6b3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -1,5 +1,7 @@ package io.mosip.testrig.apirig.admin.fw.util; +import static io.restassured.RestAssured.given; + import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; @@ -109,6 +111,7 @@ import io.mosip.testrig.apirig.testrunner.MockSMTPListener; import io.mosip.testrig.apirig.testrunner.MosipTestRunner; import io.restassured.RestAssured; +import io.restassured.http.ContentType; import io.restassured.response.Response; /** @@ -127,6 +130,10 @@ public class AdminTestUtil extends BaseTestCase { MosipTestRunner.getGlobalResourcePath() + "/" + "config/bioValue.properties"); protected static final Properties propsKernel = getproperty( MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); + public static String propsHealthCheckURL = MosipTestRunner.getResourcePath() + "/" + + "config/healthCheckEndpoint.properties"; + private static String serverComponentsCommitDetails; + String token = null; String idToken = null; String adminAutoGeneratedIdPropFileName = properties.getProperty("adminAutoGeneratedIdPropFileName"); @@ -3590,6 +3597,8 @@ public static String buildIdentityRequest(String identityRequest) { identityRequest = identityRequest.replace("$DATETIME$", generateCurrentUTCTimeStamp()); if (identityRequest.contains(GlobalConstants.TIMESTAMP)) identityRequest = identityRequest.replace(GlobalConstants.TIMESTAMP, generateCurrentUTCTimeStamp()); + if (identityRequest.contains(GlobalConstants.TRANSACTION_ID)) + identityRequest = identityRequest.replace(GlobalConstants.TRANSACTION_ID, TRANSACTION_ID); if (identityRequest.contains("$FACE$")) identityRequest = identityRequest.replace("$FACE$", propsBio.getProperty("FaceBioValue")); if (identityRequest.contains("$RIGHTIRIS$")) @@ -4834,5 +4843,50 @@ public static void checkDbAndValidate(String timeStamp, String dbChecker) throws throw new AdminTestException("Failed at output validation"); Reporter.log(ReportUtil.getOutputValidationReport(objMap)); } + + public static String getServerComponentsDetails() { + if (serverComponentsCommitDetails != null && !serverComponentsCommitDetails.isEmpty()) + return serverComponentsCommitDetails; + + File file = new File(propsHealthCheckURL); + FileReader fileReader = null; + BufferedReader bufferedReader = null; + StringBuilder stringBuilder = new StringBuilder(); + try { + fileReader = new FileReader(file); + bufferedReader = new BufferedReader(fileReader); + String line; + + while ((line = bufferedReader.readLine()) != null) { + if (line.trim().equals("") || line.trim().startsWith("#")) + continue; + String[] parts = line.trim().split("="); + if (parts.length > 1) { + + stringBuilder.append("\n").append(getCommitDetails(BaseTestCase.ApplnURI + parts[1].replace("health", "info"))); + } + } + } catch (Exception e) { + logger.error(e.getMessage()); + } finally { + AdminTestUtil.closeBufferedReader(bufferedReader); + AdminTestUtil.closeFileReader(fileReader); + } + serverComponentsCommitDetails = stringBuilder.toString(); + return serverComponentsCommitDetails; + } + + public static String getCommitDetails(String path) { + + Response response = null; + response = given().contentType(ContentType.JSON).get(path); + if (response != null && response.getStatusCode() == 200) { + logger.info(response.getBody().asString()); + JSONObject jsonResponse = new JSONObject(response.getBody().asString()); + return "Group: " + jsonResponse.getJSONObject("build").getString("group") + ", Artifact: " + jsonResponse.getJSONObject("build").getString("artifact") + ", version: " + + jsonResponse.getJSONObject("build").getString("version") + ", Commit ID: " + jsonResponse.getJSONObject("git").getJSONObject("commit").getString("id"); + } + return path + "- No Response"; + } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index 5159cf12c41..3198faba7ee 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -25,6 +25,7 @@ import org.testng.log4testng.Logger; import org.testng.xml.XmlSuite; +import io.mosip.testrig.apirig.admin.fw.util.AdminTestUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.S3Adapter; @@ -220,7 +221,12 @@ protected void writeSuiteSummary() { writer.print(""); for (int i = 1; i <= parameterCount; i++) { - writer.print(""); } writer.print(""); for (Object parameter : parameters) { + String testcaseDTO = Utils.toString(parameter).replace("TestCaseDTO(", ""); writer.print(""); } writer.print(GlobalConstants.TR); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java index ce8f5ece073..422b79f0fac 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java @@ -7,31 +7,38 @@ public class GlobalMethods { - public static void reportRequest(String request) { - if(request!=null) - Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + ReportUtil.getTextAreaJsonMsgHtml(request) - + GlobalConstants.REPORT_REQUEST_SUFFIX); + public static void reportRequest(String requestHeader, String request) { + + String formattedHeader = ReportUtil.getTextAreaForHeaders(requestHeader); + + if (request != null) + Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + formattedHeader + ReportUtil.getTextAreaJsonMsgHtml(request) + + GlobalConstants.REPORT_REQUEST_SUFFIX); else - Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + "Empty Input" - + GlobalConstants.REPORT_REQUEST_SUFFIX); + Reporter.log( + GlobalConstants.REPORT_REQUEST_PREFIX + formattedHeader + "No request body" + GlobalConstants.REPORT_REQUEST_SUFFIX); } - public static void reportResponse(String url, Response response) { - Reporter.log(GlobalConstants.REPORT_RESPONSE_PREFIX + url + GlobalConstants.REPORT_RESPONSE_BODY - + ReportUtil.getTextAreaJsonMsgHtml(response.asString()) + GlobalConstants.REPORT_RESPONSE_SUFFIX); + public static void reportResponse(String responseHeader, String url, Response response) { + String formattedHeader = ReportUtil.getTextAreaForHeaders(responseHeader); + + Reporter.log(GlobalConstants.REPORT_RESPONSE_PREFIX + url + GlobalConstants.REPORT_RESPONSE_BODY + formattedHeader + + ReportUtil.getTextAreaJsonMsgHtml(response.asString()) + GlobalConstants.REPORT_RESPONSE_SUFFIX); } - - public static void reportResponse(String url, String response) { - reportResponse(url, response, false); + + public static void reportResponse(String responseHeader, String url, String response) { + reportResponse(responseHeader, url, response, false); } - - public static void reportResponse(String url, String response, boolean formatResponse) { + + public static void reportResponse(String responseHeader, String url, String response, boolean formatResponse) { + String formattedHeader = ReportUtil.getTextAreaForHeaders(responseHeader); + if (formatResponse) - Reporter.log(GlobalConstants.REPORT_RESPONSE_PREFIX + url + GlobalConstants.REPORT_RESPONSE_BODY - + ReportUtil.getTextAreaJsonMsgHtml(response) + GlobalConstants.REPORT_RESPONSE_SUFFIX); - else - Reporter.log(GlobalConstants.REPORT_RESPONSE_PREFIX + url + GlobalConstants.REPORT_RESPONSE_BODY - + response + GlobalConstants.REPORT_RESPONSE_SUFFIX); -} + Reporter.log(GlobalConstants.REPORT_RESPONSE_PREFIX + url + GlobalConstants.REPORT_RESPONSE_BODY + formattedHeader + + ReportUtil.getTextAreaJsonMsgHtml(response) + GlobalConstants.REPORT_RESPONSE_SUFFIX); + else + Reporter.log(GlobalConstants.REPORT_RESPONSE_PREFIX + url + GlobalConstants.REPORT_RESPONSE_BODY + responseHeader + response + + GlobalConstants.REPORT_RESPONSE_SUFFIX); + } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 5a677298eae..c71e676064b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -517,7 +517,7 @@ public static String getValueFromActuators(String endPoint, String section, Stri String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new org.json.JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -575,7 +575,7 @@ public static boolean isTargetEnvLTS() { String url = ApplnURI + propsKernel.getProperty("auditActuatorEndpoint"); try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new org.json.JSONObject(response.getBody().asString()); @@ -605,7 +605,7 @@ public static List getSupportedIdTypesValueFromActuator() { String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new org.json.JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java index 3d7b15999ca..862e0d5197d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java @@ -93,10 +93,10 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { } if(pdf!=null && (new String(pdf).contains("errors")|| pdfAsText == null)) { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), "Not able to download UIN Card"); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), "Not able to download UIN Card"); } else { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java index a4e743a9814..bb55c94b0db 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java @@ -100,10 +100,10 @@ public void test(TestCaseDTO testCaseDTO) throws Exception { } if(pdf!=null && (new String(pdf).contains("errors")|| pdfAsText == null)) { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), "Not able to download"); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), "Not able to download"); } else { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); } } } @@ -117,10 +117,10 @@ public void test(TestCaseDTO testCaseDTO) throws Exception { } if(pdf!=null && (new String(pdf).contains("errors")|| pdfAsText == null)) { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), "Not able to download"); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), "Not able to download"); } else { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java index e855bb64852..b47b9dda917 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java @@ -130,10 +130,10 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } if(pdf!=null && (new String(pdf).contains("errors")|| pdfAsText == null)) { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), "Not able to download UIN Card"); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), "Not able to download UIN Card"); } else { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java index 1e8dc198bce..e8273cea97d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java @@ -92,10 +92,10 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } if(pdf!=null && (new String(pdf).contains("errors")|| pdfAsText == null)) { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), "Not able to download UIN Card"); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), "Not able to download UIN Card"); } else { - GlobalMethods.reportResponse(ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); + GlobalMethods.reportResponse(null, ApplnURI + testCaseDTO.getEndPoint(), pdfAsText); } } diff --git a/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml index cfb7ab5dd53..b459e505224 100644 --- a/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml @@ -33,7 +33,7 @@ AddIdentity: inputTemplate: mobileId/AddIdentity/addIdentity_$LANGNUMBER$ outputTemplate: mobileId/AddIdentity/addIdentityResult input: '{ - "value": "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", + "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", "biometricReferenceId": "23452353", From bcfa7345b307ffea4fb4780ea5dbb6f8563e7dd1 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 10:22:27 +0530 Subject: [PATCH 061/204] MOSIP-29068 --- .../apirig/customReport/EmailableReport.java | 28 ++++++++++--------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index 1ba720c1715..ae68e641574 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -455,20 +455,22 @@ private void writeScenario(int scenarioIndex, String label, ITestResult result) Object[] parameters = result.getParameters(); int parameterCount = (parameters == null ? 0 : parameters.length); - if (parameterCount > 0) { - writer.print(""); - for (int i = 1; i <= parameterCount; i++) { - writer.print(""); - } - writer.print(""); - for (Object parameter : parameters) { - String testcaseDTO = Utils.toString(parameter).replace("TestCaseDTO(", ""); - writer.print(""); + if (ConfigManager.IsDebugEnabled()) { + if (parameterCount > 0) { + writer.print(""); + for (int i = 1; i <= parameterCount; i++) { + writer.print(""); + } + writer.print(""); + for (Object parameter : parameters) { + String testcaseDTO = Utils.toString(parameter).replace("TestCaseDTO(", ""); + writer.print(""); + } + writer.print(GlobalConstants.TR); } - writer.print(GlobalConstants.TR); } List reporterMessages = Reporter.getOutput(result); From ab41cf0955d10cd640e91a27a688b49135a1833d Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 11:34:03 +0530 Subject: [PATCH 062/204] MOSIP-29068 --- .../io/mosip/testrig/apirig/customReport/EmailableReport.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index ae68e641574..b9fc3e26760 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -503,7 +503,7 @@ private void writeScenario(int scenarioIndex, String label, ITestResult result) writer.print("\""); } writer.print(">"); - writer.print((result.getStatus() == ITestResult.SUCCESS ? "Expected Exception" : "Exception")); + writer.print((result.getStatus() == ITestResult.SUCCESS ? "Expected Exception" : "Output Validation Exception")); writer.print(GlobalConstants.TRTR); writer.print(" reporterMessages) { - writer.print("
"); + writer.print("
"); Iterator iterator = reporterMessages.iterator(); assert iterator.hasNext(); if (Reporter.getEscapeHtml()) { From 192caf6ce834774e43f00415f7a1a9e86e7e0efe Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 13:38:27 +0530 Subject: [PATCH 063/204] MOSIP-29064 --- .../masterdata/BulkUpload/BulkUpload.yml | 4 +- .../DecommisionDevice/decommisionDevice.yml | 2 +- .../masterdata/DeleteDevice/deleteDevice.yml | 2 +- .../DeleteDeviceSpec/deleteDeviceSpec.yml | 2 +- .../DeleteMachine/DeleteMachine.yml | 2 +- .../DeleteMachineSpec/DeleteMachineSpec.yml | 2 +- .../masterdata/DeviceFilter/DeviceFilter.yml | 7 +- .../masterdata/DeviceSearch/DeviceSearch.yml | 22 +++---- .../DeviceSpecSearch/DeviceSpecSearch.yml | 32 +++++----- .../DeviceTypeFilter/DeviceTypeFilter.yml | 9 ++- .../FetchAllBlockListedWord.yml | 2 +- .../FetchAllRegCent/FetchAllRegCent.yml | 2 +- .../FetchDeviceSpec/FetchDeviceSpec.yml | 12 ---- .../FetchDocumentCategories.yml | 4 -- .../FetchGenderType/FetchGenderType.yml | 5 +- .../masterdata/FetchHolidays/FetchHoliday.yml | 13 ---- .../masterdata/FetchModule/FetchModule.yml | 2 +- .../masterdata/FetchRegCent/FetchRegCent.yml | 2 +- .../FetchTemplate/FetchTemplate.yml | 8 --- .../FetchTemplateType/FetchTemplateType.yml | 6 -- .../FilterDocCategory/FilterDocCategory.yml | 8 +-- .../FilterDocumentType/FilterDocumentType.yml | 6 +- .../FilterHolidays/FilterHolidays.yml | 29 +++++---- .../FilterMachineSpec/FilterMachineSpec.yml | 32 +++------- .../FilterMachineType/FilterMachineType.yml | 13 ++-- .../FilterRegCenterType.yml | 25 +++----- .../masterdata/GenderSearch/GenderSearch.yml | 34 ---------- .../allTxnDetails.yml | 2 +- .../getApplicationConfigs.yml | 2 +- .../GetBiometricAttributesByAuthType.yml | 2 +- .../GetDocCategory/GetDocCategory.yml | 7 -- .../GetDocCategoryByLangCode.yml | 7 -- .../GetDocumentTypeByLangCode.yml | 2 +- .../GetExceptionalHolidays.yml | 12 ---- .../GetIdTypeByLangCode.yml | 2 +- .../masterdata/GetLanguage/GetLanguage.yml | 2 +- .../GetLocationHierarchyByHierarchyName.yml | 2 +- ...ocationHierarchyLevelByLastUpdatedDate.yml | 6 -- .../masterdata/GetMachines/GetMachines.yml | 15 ----- .../masterdata/GetTemplates/GetTemplates.yml | 3 - .../GetUserDetails/GetUserDetails.yml | 4 +- .../GetValidDocument/GetValidDocument.yml | 2 +- .../GetimmediateChildrenByLocationCode.yml | 2 +- .../masterdata/Holiday/UpdateHoliday.yml | 2 +- .../HolidaySearch/HolidaySearch.yml | 5 -- .../masterdata/IdSchema/CreateIdSchema.yml | 1 - .../RegCenterFilter/RegCenterFilter.yml | 14 +--- .../SearchBlockListedWords.yml | 4 -- .../SearchDocCategories.yml | 2 +- .../SearchLocationData/SearchLocationData.yml | 1 - .../SearchMachine/SearchMachine.yml | 64 +++++++++---------- .../SearchMachine/searchMachineResult.hbs | 2 +- .../SearchMachineSpec/SearchMachineSpec.yml | 12 +--- .../SearchRegCenterType.yml | 39 +++-------- .../SearchZoneUser/SearchZoneUser.yml | 2 - .../masterdata/TitleSearch/TitleSearch.yml | 4 -- .../updateDeviceStatusResult.hbs | 2 +- .../UpdateUserCenterMapping.yml | 1 - .../UserCenterMapping/UserCenterMapping.yml | 1 - ...tregistrationmachineusermappinghistory.yml | 2 +- 60 files changed, 155 insertions(+), 362 deletions(-) diff --git a/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml b/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml index 59f64be4bad..ee6b76c41c0 100644 --- a/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml +++ b/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml @@ -1,5 +1,5 @@ BulkUpload: - Admin_BulkUpload_Smoke_sid: + Masterdata_BulkUpload_Smoke_sid: endPoint: /v1/admin/bulkupload role: admin restMethod: post @@ -15,7 +15,7 @@ BulkUpload: "tableName": "gender", "operation": "insert" }' - Admin_BulkUpload_update_gender_name: + Masterdata_BulkUpload_update_gender_name: endPoint: /v1/admin/bulkupload role: admin restMethod: post diff --git a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml index e225eee9294..a77bcfe423c 100644 --- a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml +++ b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml @@ -2,6 +2,7 @@ DecommisionDevice: MasterData_DecommisionDevice_All_Valid_Smoke_sid: endPoint: /v1/masterdata/devices/decommission/{deviceId} role: globalAdmin + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: masterdata/DecommisionDevice/decommisionDevice outputTemplate: masterdata/DecommisionDevice/decommisionDeviceResult @@ -9,7 +10,6 @@ DecommisionDevice: "deviceId": "$ID:CreateDevice_Valid_Smoke_decommison_sid_id$" }' output: '{ - "id": "$ID:CreateDevice_Valid_Smoke_decommison_sid_id$" }' MasterData_DecommisionDevice_Invalid_ID: endPoint: /v1/masterdata/devices/decommission/{deviceId} diff --git a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml index 669572cf966..7ee9b747bd4 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml +++ b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml @@ -2,6 +2,7 @@ DeleteDevice: MasterData_DeleteDevice_All_Valid_Smoke_sid: endPoint: /v1/masterdata/devices/{id} role: admin + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: masterdata/DeleteDevice/deleteDevice outputTemplate: masterdata/DeleteDevice/deleteDeviceResult @@ -9,5 +10,4 @@ DeleteDevice: "id": "$ID:CreateDevice_All_Valid_Smoke_sid_id$" }' output: '{ - "id": "$ID:CreateDevice_All_Valid_Smoke_sid_id$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpec.yml b/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpec.yml index e8121109f68..9e4ca561f07 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpec.yml +++ b/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpec.yml @@ -2,6 +2,7 @@ DeleteDeviceSpec: MasterData_DeleteDeviceSpec_All_Valid_Smoke_sid: endPoint: /v1/masterdata/devicespecifications/{id} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: delete inputTemplate: masterdata/DeleteDeviceSpec/deleteDeviceSpec @@ -10,7 +11,6 @@ DeleteDeviceSpec: "id": "$ID:CreateDeviceSpecification_All_Valid_Smoke_sid_id$" }' output: '{ - "id": "$ID:CreateDeviceSpecification_All_Valid_Smoke_sid_id$" }' MasterData_DeleteDeviceSpec_Invalid_ID: endPoint: /v1/masterdata/devicespecifications/{id} diff --git a/automationtests/src/main/resources/masterdata/DeleteMachine/DeleteMachine.yml b/automationtests/src/main/resources/masterdata/DeleteMachine/DeleteMachine.yml index 2129c74b0d8..4e6a7febce9 100644 --- a/automationtests/src/main/resources/masterdata/DeleteMachine/DeleteMachine.yml +++ b/automationtests/src/main/resources/masterdata/DeleteMachine/DeleteMachine.yml @@ -2,6 +2,7 @@ DeleteMachine: MasterData_DeleteMachine_All_Valid_Smoke_sid: endPoint: /v1/masterdata/machines/{id} role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: delete inputTemplate: masterdata/DeleteMachine/deleteMachine @@ -10,7 +11,6 @@ DeleteMachine: "id": "$ID:CreateMachine_All_Valid_Smoke_sid_id$" }' output: '{ - "id": "$IGNORE$" }' MasterData_DeleteMachine_Invalid_ID: endPoint: /v1/masterdata/machines/{id} diff --git a/automationtests/src/main/resources/masterdata/DeleteMachineSpec/DeleteMachineSpec.yml b/automationtests/src/main/resources/masterdata/DeleteMachineSpec/DeleteMachineSpec.yml index d24a7f5cffd..c8ac87c2271 100644 --- a/automationtests/src/main/resources/masterdata/DeleteMachineSpec/DeleteMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/DeleteMachineSpec/DeleteMachineSpec.yml @@ -2,6 +2,7 @@ DeleteMachineSpec: MasterData_DeleteMachineSpec_All_Valid_Smoke_sid: endPoint: /v1/masterdata/machinespecifications/{id} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: delete inputTemplate: masterdata/DeleteMachineSpec/deleteMachineSpec @@ -10,7 +11,6 @@ DeleteMachineSpec: "id": "$ID:CreateMachineSpecification_All_Valid_Smoke_sid_id$" }' output: '{ - "id": "$IGNORE$" }' MasterData_DeleteMachineSpec_Invalid_ID: endPoint: /v1/masterdata/machinespecifications/{id} diff --git a/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml b/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml index 81aab5bedaa..6a853353deb 100644 --- a/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml +++ b/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml @@ -99,6 +99,7 @@ DeviceFilter: MasterData_DeviceFilter_SerialNum_Unique_smoke: endPoint: /v1/masterdata/devices/filtervalues role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceFilter/deviceFilter @@ -113,12 +114,6 @@ DeviceFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$" - } - ] }' MasterData_DeviceFilter_Invalid_RequestTime: diff --git a/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml b/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml index 3babaee6ef7..4aad1aa5950 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml @@ -87,6 +87,7 @@ DeviceSearch: MasterData_DeviceSearch_Equals_MacAddress_smoke: endPoint: /v1/masterdata/devices/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceSearch/deviceSearch @@ -113,18 +114,6 @@ DeviceSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "description": "$IGNORE$", - "macAddress": "$IGNORE$", - "ipAddress": "$IGNORE$", - "deviceSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "validityDateTime": "$IGNORE$" - }] }' MasterData_DeviceSearch_ASC_Name_eng_pos: endPoint: /v1/masterdata/devices/search @@ -218,7 +207,7 @@ DeviceSearch: templateFields: ["value"] restMethod: post inputTemplate: masterdata/DeviceSearch/deviceSearch - outputTemplate: masterdata/DeviceSearch/deviceSearchResult + outputTemplate: masterdata/error input: '{ "filters": [ { @@ -241,7 +230,12 @@ DeviceSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [] + "errors": [ + { + "errorCode": "KER-MSD-358", + "message": "$IGNORE$" + } + ] }' MasterData_DeviceSearch_Invalid_SortType_neg: endPoint: /v1/masterdata/devices/search diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml index 47ac9a57fda..9e8774eaf08 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml @@ -174,7 +174,7 @@ DeviceSpecSearch: templateFields: [] restMethod: post inputTemplate: masterdata/DeviceSpecSearch/deviceSpecSearch - outputTemplate: masterdata/DeviceSpecSearch/deviceSpecSearchResult + outputTemplate: masterdata/error input: '{ "filters": [ { @@ -197,7 +197,12 @@ DeviceSpecSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [] + "errors": [ + { + "errorCode": "KER-MSD-317", + "message": "$IGNORE$" + } + ] }' MasterData_DeviceSpecSearch_InvalidPageFetch: endPoint: /v1/masterdata/devicespecifications/search @@ -205,7 +210,7 @@ DeviceSpecSearch: templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceSpecSearch/deviceSpecSearch - outputTemplate: masterdata/DeviceSpecSearch/deviceSpecSearchResult + outputTemplate: masterdata/error input: '{ "filters": [ { @@ -228,7 +233,12 @@ DeviceSpecSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [] + "errors": [ + { + "errorCode": "KER-MSD-313", + "message": "$IGNORE$" + } + ] }' MasterData_DeviceSpecSearch_InvalidPageStart: endPoint: /v1/masterdata/devicespecifications/search @@ -539,6 +549,7 @@ DeviceSpecSearch: MasterData_DeviceSpecSearch_TwoValueSearch_pos: endPoint: /v1/masterdata/devicespecifications/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceSpecSearch/deviceSpecSearch @@ -572,18 +583,7 @@ DeviceSpecSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ - "id": "$IGNORE$", - "name": "$IGNORE$", - "brand": "$IGNORE$", - "model": "$IGNORE$", - "deviceTypeCode": "$IGNORE$", - "minDriverversion": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "deviceTypeName": "$IGNORE$" - }] + }' MasterData_DeviceSpecSearch_StartsWith_Name_eng: endPoint: /v1/masterdata/devicespecifications/search diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml index b52ff3abcdd..685fcdf2f5c 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml +++ b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml @@ -101,7 +101,7 @@ DeviceTypeFilter: templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceTypeFilter/deviceTypeFilter - outputTemplate: masterdata/DeviceTypeFilter/deviceTypeFilterResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "name", @@ -112,7 +112,12 @@ DeviceTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] + "errors": [ + { + "errorCode": "KER-MSD-322", + "message": "Filter Type cannot be empty or null" + } + ] }' MasterData_DeviceTypeFilter_Invalid_FilterType_neg: endPoint: /v1/masterdata/devicetypes/filtervalues diff --git a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml index 1073a776ee2..1c9138ae254 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml @@ -1,5 +1,5 @@ FetchAllBlockListedWord: - Kernel_FetchAllBlockListedWord_valid_smoke: + Master_FetchAllBlockListedWord_valid_smoke: endPoint: /v1/masterdata/blocklistedwords/all role: admin checkErrorsOnlyInResponse: true diff --git a/automationtests/src/main/resources/masterdata/FetchAllRegCent/FetchAllRegCent.yml b/automationtests/src/main/resources/masterdata/FetchAllRegCent/FetchAllRegCent.yml index 425e79ab4be..dccc4f78314 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllRegCent/FetchAllRegCent.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllRegCent/FetchAllRegCent.yml @@ -2,6 +2,7 @@ FetchAllRegCent: MasterData_FetchAllRegCent_valid_smoke: endPoint: /v1/masterdata/registrationcenters/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllRegCent/fetchAllRegCent outputTemplate: masterdata/FetchAllRegCent/fetchAllRegCentResult @@ -9,5 +10,4 @@ FetchAllRegCent: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml index aba0961abe0..13cc02db144 100644 --- a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml @@ -12,10 +12,6 @@ FetchDeviceSpec: "langcode": "eng" }' output: '{ -"devicespecifications": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchDeviceSpec_allValid_byDeviceTypeCode_smoke: endPoint: /v1/masterdata/devicespecifications/devicetypecode/{devicetypecode} @@ -30,10 +26,6 @@ FetchDeviceSpec: "langcode": "$REMOVE$" }' output: '{ -"devicespecifications": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchDeviceSpec_allValid_smoke_with_lang_and_deviceType: endPoint: /v1/masterdata/devicespecifications/{langcode}/{devicetypecode} @@ -48,10 +40,6 @@ FetchDeviceSpec: "langcode": "eng" }' output: '{ -"devicespecifications": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchDeviceSpec_invalid_devicetypecode_unexisting: endPoint: /v1/masterdata/devicespecifications/{langcode}/{devicetypecode} diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml index c3caa3c3366..3d61f80724a 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml +++ b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml @@ -50,8 +50,4 @@ FetchDocumentCategories: "langcode":"eng" }' output: '{ -"documentcategories": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml b/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml index e69780a05da..14696e22d0f 100644 --- a/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml +++ b/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml @@ -10,10 +10,7 @@ FetchGenderType: "gendername":"$REMOVE$" }' output: '{ -"genderType": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] + }' Masterdata_FetchGenderType_Validate_gender_name_smoke: diff --git a/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml b/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml index 679b792cd65..f4a864bb571 100644 --- a/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml +++ b/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml @@ -10,10 +10,6 @@ FetchHolidays: "langcode": "$REMOVE$" }' output: '{ -"holidays": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchHolidays_allValid_smoke_with Id: @@ -27,10 +23,6 @@ FetchHolidays: "langcode":"$REMOVE$" }' output: '{ -"holidays": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchHolidays_allValid_smoke_with Id and langCode: endPoint: /v1/masterdata/holidays/{holidayid}/{langcode} @@ -43,11 +35,6 @@ FetchHolidays: "langcode":"eng" }' output: '{ -"holidays": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - } - ] }' MasterData_FetchHolidays_invalid_holidayid_unexisting: endPoint: /v1/masterdata/holidays/{holidayid} diff --git a/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml b/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml index b063ed51f7f..887861a32b2 100644 --- a/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml +++ b/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml @@ -14,7 +14,7 @@ FetchModule: "name": "$IGNORE$", "langCode": "eng", "description": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' MasterData_FetchModule_Invalid_smoke_with_Invalid_langcode: diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml index eebb6bcce5b..7f89e33735e 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml @@ -379,7 +379,7 @@ FetchRegCent: "timestamp": "2021-01-20T06:22:07.797Z" }' output: '{ - "status":"$IGNORE$" + "status":"Valid" }' MasterData_FetchRegCent_validateTimestamp_invalid_id: diff --git a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml index 38d6bcd6adb..8938aab584f 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml +++ b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml @@ -11,10 +11,6 @@ FetchTemplate: "templatetypecode": "$REMOVE$" }' output: '{ -"templates": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchTemplate_allValid_ByLangcode_smoke: endPoint: /v1/masterdata/templates/{langcode} @@ -28,10 +24,6 @@ FetchTemplate: "templatetypecode": "$REMOVE$" }' output: '{ -"templates": [{ - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' MasterData_FetchTemplate_allValid_smoke_with_lang_and_templatetypecode: endPoint: /v1/masterdata/templates/{langcode}/{templatetypecode} diff --git a/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml b/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml index 32b7c0a9599..d3485a8e1f1 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml +++ b/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml @@ -11,9 +11,6 @@ FetchTemplateType: "code": "auth-email-content" }' output: '{ -"templateTypes": [{ - "isActive": $IGNORE$ - }] }' MasterData_FetchTemplateType_inValid_code: endPoint: /v1/masterdata/templatetypes/{code}/{langcode} @@ -46,8 +43,5 @@ FetchTemplateType: "code": "$REMOVE$" }' output: '{ -"templateTypes": [{ - "isActive": $IGNORE$ - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml b/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml index 4db16a6375b..436cfd79cc9 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml +++ b/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml @@ -2,6 +2,7 @@ FilterDocCategory: MasterData_FilterDocCategory_Valid_Request_Smoke: endPoint: /v1/masterdata/documentcategories/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterDocCategory/filterDocCategory @@ -16,11 +17,11 @@ FilterDocCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' MasterData_FilterDocCategory_Valid_column_code_filterType_all: endPoint: /v1/masterdata/documentcategories/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterDocCategory/filterDocCategory @@ -35,7 +36,6 @@ FilterDocCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' MasterData_FilterDocCategory_inValid_filterColumnName_blank: @@ -135,9 +135,10 @@ FilterDocCategory: } ] }' - MasterData_FilterDocCategory_inValid_FilterText: + MasterData_FilterDocCategory_Empty_FilterText_Pos: endPoint: /v1/masterdata/documentcategories/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterDocCategory/filterDocCategory @@ -152,5 +153,4 @@ FilterDocCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDocumentType/FilterDocumentType.yml b/automationtests/src/main/resources/masterdata/FilterDocumentType/FilterDocumentType.yml index 7aa4848cac0..5ffcf4dade0 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocumentType/FilterDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/FilterDocumentType/FilterDocumentType.yml @@ -50,6 +50,7 @@ FilterDocumentType: MasterData_FilterDocumentType_Valid_column_code_filterType_all: endPoint: /v1/masterdata/documenttypes/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterDocumentType/filterDocumentType @@ -64,7 +65,6 @@ FilterDocumentType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' MasterData_FilterDocCatTypMapping_inValid_filterType_blank: endPoint: /v1/masterdata/documenttypes/filtervalues @@ -163,9 +163,10 @@ FilterDocumentType: } ] }' - MasterData_FilterDocumentType_inValid_FilterText: + MasterData_FilterDocumentType_Empty_FilterText_Pos: endPoint: /v1/masterdata/documenttypes/filtervalues role: admin + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: masterdata/FilterDocumentType/filterDocumentType outputTemplate: masterdata/FilterDocumentType/filterDocumentTypeResult @@ -179,5 +180,4 @@ FilterDocumentType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml b/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml index 92550c491cc..81c3239e37e 100644 --- a/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml +++ b/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml @@ -2,6 +2,7 @@ FilterHolidays: MasterData_FilterHolidays_Valid_Smoke: endPoint: /v1/masterdata/holidays/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterHolidays/filterHolidays @@ -16,12 +17,6 @@ FilterHolidays: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$" - } - ] }' MasterData_FilterHolidays_inValid_filterText: @@ -29,18 +24,23 @@ FilterHolidays: role: admin restMethod: post inputTemplate: masterdata/FilterHolidays/filterHolidays - outputTemplate: masterdata/FilterHolidays/filterHolidaysResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "isActive", "type": "unique", - "text": "ashash" + "text": "ashashadf" }], "languageCode": "eng", "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] + "errors": [ + { + "errorCode": "KER-MSD-324", + "message": "$IGNORE$" + } + ] }' MasterData_FilterHolidays_inValid_filterType_blank: endPoint: /v1/masterdata/holidays/filtervalues @@ -152,7 +152,7 @@ FilterHolidays: "text": "AutoTest user" }], "languageCode": "eng", - "requesttime": "$TIMESTAMP" + "requesttime": "$TIMESTAMP$" }' output: '{ "errors": [ @@ -200,8 +200,13 @@ FilterHolidays: "text": "sdfgsds" }], "languageCode": "eng", - "requesttime": "$TIMESTAMP" + "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] + "errors": [ + { + "errorCode": "KER-MSD-999", + "message": "$IGNORE$" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml b/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml index cd92aaf7fd0..376dd826822 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml @@ -146,6 +146,7 @@ FilterMachineSpec: Masterdata_FilterMachineSpec_Valid_filterText_blank: endPoint: /v1/masterdata/machinespecifications/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterMachineSpec/filterMachineSpec @@ -160,28 +161,6 @@ FilterMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$", - "fieldCode": "HP04" - }, - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$", - "fieldCode": "0" - }, - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$", - "fieldCode": "123" - }, - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$", - "fieldCode": "1001" - } - ] }' Masterdata_FilterMachineSpec_inValid_filterType_blank: endPoint: /v1/masterdata/machinespecifications/filtervalues @@ -309,7 +288,7 @@ FilterMachineSpec: templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterMachineSpec/filterMachineSpec - outputTemplate: masterdata/FilterMachineSpec/filterMachineSpecResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "name", @@ -320,5 +299,10 @@ FilterMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] + "errors": [ + { + "errorCode": "KER-MSD-317", + "message": "$IGNORE$" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml b/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml index 45293e757cd..0672196647c 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml +++ b/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml @@ -2,6 +2,7 @@ FilterMachineType: Masterdata_FilterMachineType_Valid_Smoke: endPoint: /v1/masterdata/machinetypes/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterMachineType/filterMachineType @@ -16,11 +17,11 @@ FilterMachineType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' Masterdata_FilterMachineType_Valid_col_as_name_filterType_all: endPoint: /v1/masterdata/machinetypes/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterMachineType/filterMachineType @@ -35,7 +36,6 @@ FilterMachineType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' Masterdata_FilterMachineType_inValid_filterType_blank: @@ -164,7 +164,7 @@ FilterMachineType: templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterMachineType/filterMachineType - outputTemplate: masterdata/FilterMachineType/filterMachineTypeResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "name", @@ -175,5 +175,10 @@ FilterMachineType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] + "errors": [ + { + "errorCode": "KER-MSD-317", + "message": "$IGNORE$" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml b/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml index 32d316c284f..2ede1ec50f4 100644 --- a/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml @@ -2,6 +2,7 @@ FilterRegCenterType: MasterData_FilterRegCenterType_Valid_Smoke: endPoint: /v1/masterdata/registrationcentertypes/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterRegCenterType/filterRegCenterType @@ -16,17 +17,11 @@ FilterRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$", - "fieldCode": "$IGNORE$" - } - ] }' MasterData_FilterRegCenterType_Valid_col_name_withText: endPoint: /v1/masterdata/registrationcentertypes/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterRegCenterType/filterRegCenterType @@ -41,13 +36,6 @@ FilterRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$", - "fieldCode":"$IGNORE$" - } - ] }' MasterData_FilterRegCenterType_Valid_col_code: endPoint: /v1/masterdata/registrationcentertypes/filtervalues @@ -115,7 +103,7 @@ FilterRegCenterType: templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterRegCenterType/filterRegCenterType - outputTemplate: masterdata/FilterRegCenterType/filterRegCenterTypeResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "code", @@ -126,7 +114,12 @@ FilterRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] + "errors": [ + { + "errorCode": "KER-MSD-317", + "message": "$IGNORE$" + } + ] }' MasterData_FilterRegCenterType_inValid_filterType_blank: endPoint: /v1/masterdata/registrationcentertypes/filtervalues diff --git a/automationtests/src/main/resources/masterdata/GenderSearch/GenderSearch.yml b/automationtests/src/main/resources/masterdata/GenderSearch/GenderSearch.yml index 0b11aa147b6..f025df23190 100644 --- a/automationtests/src/main/resources/masterdata/GenderSearch/GenderSearch.yml +++ b/automationtests/src/main/resources/masterdata/GenderSearch/GenderSearch.yml @@ -20,14 +20,6 @@ GenderSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": $IGNORE$, - "code": "$IGNORE$", - "genderName": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] }' Masterdata_GenderSearch_valid_lang: endPoint: /v1/masterdata/gendertypes/search @@ -56,15 +48,6 @@ GenderSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "code": "$IGNORE$", - "genderName": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] }' Masterdata_GenderSearch_Valid_langCodeAsEng_sortBy_code: endPoint: /v1/masterdata/gendertypes/search @@ -87,14 +70,6 @@ GenderSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": $IGNORE$, - "code": "$IGNORE$", - "genderName": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] }' Masterdata_GenderSearch_InvalidSortFieldAsEmpty: endPoint: /v1/masterdata/gendertypes/search @@ -233,13 +208,4 @@ GenderSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "code": "$IGNORE$", - "genderName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$, - "createdBy": "$IGNORE$" - } - ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml index 0f05fd7ae20..a3385d629ff 100644 --- a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml +++ b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml @@ -1,5 +1,5 @@ GetAllTxnDetailBulkUpload: - master_GetAllTxnDetailBulkUpload_Smoke: + Master_GetAllTxnDetailBulkUpload_Smoke: endPoint: /v1/admin/bulkupload/getAllTransactions role: admin checkErrorsOnlyInResponse: true diff --git a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml index b9a40d51058..2ff960fcf2b 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml +++ b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml @@ -1,5 +1,5 @@ GetCredentialTypes: - master_GetApplicationConfigs_smoke: + Master_GetApplicationConfigs_smoke: endPoint: /v1/masterdata/applicationconfigs role: admin checkErrorsOnlyInResponse: true diff --git a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml index 950d18c5a96..e8e18abe466 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml +++ b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml @@ -16,7 +16,7 @@ GetBiometricAttributesByAuthType: "description": "$IGNORE$", "biometricTypeCode": "FNR", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml b/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml index f0e61adc7fd..64ca411cef0 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml +++ b/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml @@ -9,11 +9,4 @@ GetDocCategory: }' output: '{ -"documentcategories": [{ - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml index 3b0cff6bf67..cf0dfa9cd16 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml @@ -10,13 +10,6 @@ GetDocCategoryByLangCode: "langcode":"eng" }' output: '{ -"documentcategories": [{ - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' Admin_GetDocCategoryByLangCode_Invalid_code: diff --git a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml index 32096851523..e5510906ffb 100644 --- a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml @@ -14,7 +14,7 @@ GetDocumentTypeByLangCode: "name": "$IGNORE$", "description": "$IGNORE$", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml index bee8085cb38..b77fd17f631 100644 --- a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml +++ b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml @@ -11,18 +11,6 @@ GetExceptionalHolidays: "langCode":"eng" }' output: '{ -"exceptionalHolidayList": [{ - "holidayDate": "$IGNORE$", - "holidayDay": "$IGNORE$", - "holidayMonth": "$IGNORE$", - "holidayYear": "$IGNORE$", - "holidayName": "$IGNORE$", - "holidayReason": "$IGNORE$", - "registrationCenterID": "$IGNORE$", - "isDeleted": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' Admin_GetExceptionalHolidays_InValid_Invalid_registrationCenterId: diff --git a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml index df2b99e01ad..a8e29e4cd3f 100644 --- a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml @@ -14,7 +14,7 @@ GetIdTypeByLangCode: "descr": "$IGNORE$", "name": "$IGNORE$", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml b/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml index 2163721b9f8..1dc8f0c0736 100644 --- a/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml +++ b/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml @@ -14,6 +14,6 @@ GetLanguage: "name": "$IGNORE$", "family": "$IGNORE", "nativeName": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml index 9f697177e59..b440ed60f57 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml @@ -16,7 +16,7 @@ GetLocationHierarchyByHierarchyName: "hierarchyName": "City", "parentLocCode": "$IGNORE$", "langCode": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml index 6ec2fbc856a..a028634552f 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml @@ -9,12 +9,6 @@ GetLocationHierarchyLevelByLastUpdatedDate: }' output: '{ -"locationHierarchyLevels": [{ - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - }] }' Admin_GetLocationHierarchyLevelByLastUpdatedDate_Invalid_Invalid_lD: diff --git a/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml b/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml index 292fd0c372d..778430b20d7 100644 --- a/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml +++ b/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml @@ -9,19 +9,4 @@ GetMachines: }' output: '{ -"machines": [{ - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "macAddress": "$IGNORE$", - "ipAddress": "$IGNORE$", - "machineSpecId": "$IGNORE$", - "regCenterId": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$, - "validityDateTime": "$IGNORE$", - "publicKey":"$IGNORE$", - "signPublicKey": "$IGNORE$", - "zoneCode": "$IGNORE$" - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplates/GetTemplates.yml b/automationtests/src/main/resources/masterdata/GetTemplates/GetTemplates.yml index 2ba55eabbfb..4f5a7829a68 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplates/GetTemplates.yml +++ b/automationtests/src/main/resources/masterdata/GetTemplates/GetTemplates.yml @@ -9,7 +9,4 @@ GetTemplates: }' output: '{ -"templates": [{ - "isActive": $IGNORE$ - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml b/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml index be57dbf1fdc..1b8718b9bcf 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml @@ -14,7 +14,7 @@ GetUserDetails: "name": "$IGNORE$", "statusCode": "$IGNORE$", "regCenterId": "10005", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "zoneCode": "$IGNORE$" }' MasterData_GetUserDetails_ByUserId_allValid_smoke: @@ -32,7 +32,7 @@ GetUserDetails: "name": "$IGNORE$", "statusCode": "$IGNORE$", "regCenterId": "10005", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "zoneCode": "$IGNORE$" }' MasterData_GetUserDetails_InValid_InvalidUserID: diff --git a/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml b/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml index efc4875ca29..4d4b64653b2 100644 --- a/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml +++ b/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml @@ -15,6 +15,6 @@ GetValidDocument: "docCategoryCode": "$IGNORE$", "docTypeName": "$IGNORE$", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml index c685efa7b44..88e6178c550 100644 --- a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml +++ b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml @@ -17,7 +17,7 @@ GetimmediateChildrenByLocationCode: "hierarchyName": "$IGNORE$", "parentLocCode": "$IGNORE$", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml index e7ce4bbba98..f434564b288 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml +++ b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml @@ -17,7 +17,7 @@ UpdateHoliday: "requesttime": "$TIMESTAMP$" }' output: '{ - "holidayId": $IGNORE$, + "holidayId": "$IGNORE$", "locationCode": "$IGNORE$", "holidayDate": "2020-08-15", "holidayName": "AutoTest user", diff --git a/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml b/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml index 1bd70ed17fc..04a1998e146 100644 --- a/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml +++ b/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml @@ -28,7 +28,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", "holidayDate": "2020-08-15", @@ -65,7 +64,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", "holidayDate": "2020-08-15", @@ -102,7 +100,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", "holidayDate": "2020-08-15", @@ -139,7 +136,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", "holidayDate": "2020-08-15", @@ -176,7 +172,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", "holidayDate": "2020-08-15", diff --git a/automationtests/src/main/resources/masterdata/IdSchema/CreateIdSchema.yml b/automationtests/src/main/resources/masterdata/IdSchema/CreateIdSchema.yml index 5bb7196cb0f..8ddbb8bd493 100644 --- a/automationtests/src/main/resources/masterdata/IdSchema/CreateIdSchema.yml +++ b/automationtests/src/main/resources/masterdata/IdSchema/CreateIdSchema.yml @@ -13,7 +13,6 @@ CreateIdSchema: }' output: '{ "id": "$IGNORE$", - "idVersion": $IGNORE$, "title": "test-schema", "description": "Testing purpose", "schemaJson": "$IGNORE$" diff --git a/automationtests/src/main/resources/masterdata/RegCenterFilter/RegCenterFilter.yml b/automationtests/src/main/resources/masterdata/RegCenterFilter/RegCenterFilter.yml index b185d4d780a..98d14015390 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterFilter/RegCenterFilter.yml +++ b/automationtests/src/main/resources/masterdata/RegCenterFilter/RegCenterFilter.yml @@ -2,6 +2,7 @@ RegCenterFilter: MasterData_RegCenterFilter_Name_eng_Unique_smoke: endPoint: /v1/masterdata/registrationcenters/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/RegCenterFilter/regCenterFilter @@ -16,16 +17,11 @@ RegCenterFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$" - } - ] }' MasterData_RegCenterFilter_Name_eng_All_smoke: endPoint: /v1/masterdata/registrationcenters/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/RegCenterFilter/regCenterFilter @@ -40,12 +36,6 @@ RegCenterFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { - "fieldID": "$IGNORE$", - "fieldValue": "$IGNORE$" - } - ] }' MasterData_RegCenterFilter_Invalid_RequestTime: diff --git a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml index d81511fc981..4dcd34f0058 100644 --- a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml @@ -30,7 +30,6 @@ SearchBlockListedWords: output: '{ "data": [ { - "isActive": $IGNORE$, "description": "$IGNORE$", "word": "dumbo7", "langCode": "eng" @@ -68,7 +67,6 @@ SearchBlockListedWords: output: '{ "data": [ { - "isActive": $IGNORE$, "description": "$IGNORE$", "word": "dumbo7", "langCode": "eng" @@ -106,7 +104,6 @@ SearchBlockListedWords: output: '{ "data": [ { - "isActive": $IGNORE$, "description": "$IGNORE$", "word": "dumbo7", "langCode": "eng" @@ -180,7 +177,6 @@ SearchBlockListedWords: output: '{ "data": [ { - "isActive": $IGNORE$, "description": "$IGNORE$", "word": "dumb7", "langCode": "eng" diff --git a/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml b/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml index d4814e6e1b1..4fa7c7e1e99 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml +++ b/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml @@ -2,6 +2,7 @@ SearchDocCategories: MasterData_SearchDocCategories_Valid_Request_Smoke: endPoint: /v1/masterdata/documentcategories/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchDocCategories/searchDocCategories @@ -35,7 +36,6 @@ SearchDocCategories: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [] }' MasterData_SearchDocCategories_Valid_sortBy_code: endPoint: /v1/masterdata/documentcategories/search diff --git a/automationtests/src/main/resources/masterdata/SearchLocationData/SearchLocationData.yml b/automationtests/src/main/resources/masterdata/SearchLocationData/SearchLocationData.yml index 0feb3d5f80f..45d755c5dc2 100644 --- a/automationtests/src/main/resources/masterdata/SearchLocationData/SearchLocationData.yml +++ b/automationtests/src/main/resources/masterdata/SearchLocationData/SearchLocationData.yml @@ -30,7 +30,6 @@ SearchLocationData: output: '{ "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", - "isActive": $IGNORE$, "region": "$IGNORE$", "city": "$IGNORE$", "province": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml index 7719616787f..ee70058aa49 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml @@ -33,11 +33,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_FilterTypeContains: endPoint: /v1/masterdata/machines/search @@ -73,11 +73,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_FilterTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -113,11 +113,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnMacAddressNFilterTypeEquals: endPoint: /v1/masterdata/machines/search @@ -153,11 +153,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnMacAddressNTypeContains: endPoint: /v1/masterdata/machines/search @@ -193,11 +193,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnMacAddressNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -233,11 +233,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeEquals: endPoint: /v1/masterdata/machines/search @@ -273,11 +273,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "$IGNORE$", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeContains: endPoint: /v1/masterdata/machines/search @@ -313,11 +313,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "$IGNORE$", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -353,11 +353,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "$IGNORE$", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeEquals: endPoint: /v1/masterdata/machines/search @@ -393,11 +393,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "$IGNORE$", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeContains: endPoint: /v1/masterdata/machines/search @@ -433,11 +433,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "$IGNORE$", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -473,11 +473,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "$IGNORE$", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_TwoFilterValues_TypeEqualsNEquals: endPoint: /v1/masterdata/machines/search @@ -520,11 +520,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_SortFieldDESC: endPoint: /v1/masterdata/machines/search @@ -560,11 +560,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_TwoSortFields_DescNDesc: endPoint: /v1/masterdata/machines/search @@ -604,11 +604,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Valid_TwoSortFields_AscNDesc: endPoint: /v1/masterdata/machines/search @@ -648,11 +648,11 @@ SearchMachine: "serialNum": "FB5962911687", "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", - "machineSpecId": "1001", + "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", "zoneCode": "CST", "zone": "$IGNORE$", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }' Masterdata_SearchMachine_Invalid_ColumnName: endPoint: /v1/masterdata/machines/search diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs index 915e17629f5..5b1c05c3b07 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs @@ -24,7 +24,7 @@ "langCode": "{{langCode}}", "zoneCode": "{{zoneCode}}", "zone": "{{zone}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml index 469eabea9b7..ce61d7b2469 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml @@ -160,6 +160,7 @@ SearchMachineSpec: Masterdata_SearchMachineSpec_Valid_col_as_isActive: endPoint: /v1/masterdata/machinespecifications/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachineSpec/searchMachineSpec @@ -184,17 +185,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ - "id": "$IGNORE$", - "name": "HP", - "brand": "HP", - "model": "1234", - "machineTypeCode": "$IGNORE$", - "minDriverversion": "3.2", - "description": "HP brand", - "langCode": "eng", - "isActive": "$IGNORE$" - }] }' Masterdata_SearchMachineSpec_Valid_col_as_Name_FltrTyp_startsWith: endPoint: /v1/masterdata/machinespecifications/search diff --git a/automationtests/src/main/resources/masterdata/SearchRegCenterType/SearchRegCenterType.yml b/automationtests/src/main/resources/masterdata/SearchRegCenterType/SearchRegCenterType.yml index c45f7e4eee9..dee36447f6a 100644 --- a/automationtests/src/main/resources/masterdata/SearchRegCenterType/SearchRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/SearchRegCenterType/SearchRegCenterType.yml @@ -2,6 +2,7 @@ SearchRegCenterType: MasterData_SearchRegCenterType_allValid_somke: endPoint: /v1/masterdata/registrationcentertypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchRegCenterType/searchRegCenterType @@ -26,15 +27,6 @@ SearchRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": $IGNORE$, - "code": "$IGNORE$", - "name": "$IGNORE$", - "descr": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] }' MasterData_SearchRegCenterType_valid_col_isActive_true: @@ -77,6 +69,7 @@ SearchRegCenterType: MasterData_SearchRegCenterType_valid_typeFilter_contains: endPoint: /v1/masterdata/registrationcentertypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchRegCenterType/searchRegCenterType @@ -101,19 +94,11 @@ SearchRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": $IGNORE$, - "code": "$IGNORE$", - "name": "$IGNORE$", - "descr": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] }' MasterData_SearchRegCenterType_valid_typeFilter_startsWith: endPoint: /v1/masterdata/registrationcentertypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchRegCenterType/searchRegCenterType @@ -138,15 +123,6 @@ SearchRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": $IGNORE$, - "code": "$IGNORE$", - "name": "$IGNORE$", - "descr": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] }' MasterData_SearchRegCenterType_inValid_columnName_blank: endPoint: /v1/masterdata/registrationcentertypes/search @@ -222,7 +198,7 @@ SearchRegCenterType: templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchRegCenterType/searchRegCenterType - outputTemplate: masterdata/SearchRegCenterType/searchRegCenterTypeResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "name", @@ -243,7 +219,12 @@ SearchRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [] + "errors": [ + { + "errorCode": "KER-MSD-390", + "message": "$IGNORE$" + } + ] }' MasterData_SearchRegCenterType_inValid_filter_value_blank: endPoint: /v1/masterdata/registrationcentertypes/search diff --git a/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml b/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml index de87559b950..0781fdc6362 100644 --- a/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml @@ -27,12 +27,10 @@ SearchZoneUser: "requesttime": "$TIMESTAMP$" }' output: '{ - "isActive": $IGNORE$, "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, "deletedDateTime": "$IGNORE$", "zoneCode": "$IGNORE$", "userId": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml b/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml index cf48cb2879c..ef888197b48 100644 --- a/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml +++ b/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml @@ -83,7 +83,6 @@ TitleSearch: output: '{ "data": [ { - "isActive": $IGNORE$, "code": "TEST0011", "titleName": "TEST0011", "titleDescription": "TEST0011", @@ -120,7 +119,6 @@ TitleSearch: output: '{ "data": [ { - "isActive": $IGNORE$, "code": "TEST0011", "titleName": "TEST0011", "titleDescription": "$IGNORE$", @@ -459,7 +457,6 @@ TitleSearch: output: '{ "data": [ { - "isActive": $IGNORE$, "code": "TEST0011", "titleName": "TEST0011", "titleDescription": "TEST0011", @@ -496,7 +493,6 @@ TitleSearch: output: '{ "data": [ { - "isActive": $IGNORE$, "code": "TEST0011", "titleName": "TEST0011", "titleDescription": "TEST0011", diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs index 1382843c154..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs @@ -1,5 +1,5 @@ { - "id": "$IGNORE$, + "id": "$IGNORE$", "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml b/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml index 29b8e2d8b12..54c163a83a8 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml @@ -20,7 +20,6 @@ UpdateUserCenterMapping: "name": "automationUpdated", "statusCode": "active", "regCenterId": "10005", - "isActive": $IGNORE$, "zoneCode": "BSN", "zoneName": "Benslimane", "regCenterName": "Center Mehdia" diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml b/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml index d283140b8e1..21bb134e3c6 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml @@ -21,7 +21,6 @@ UserCenterMapping: "name": "automation", "statusCode": "active", "regCenterId": "10005", - "isActive": $IGNORE$, "zoneCode": "BSN", "zoneName": "Benslimane", "regCenterName": "Center Mehdia" diff --git a/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistory.yml b/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistory.yml index 3072cd3461b..2912f665010 100644 --- a/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistory.yml +++ b/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistory.yml @@ -16,7 +16,7 @@ getregistrationmachineusermappinghistory: "cntrId": "10001", "machineId": "10001", "usrId": "110001", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "langCode": "$IGNORE$", "effectivetimes": "$IGNORE$" }] From 1bdf6b463fd5610605783e066aaaa7b797f5304b Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 13:49:34 +0530 Subject: [PATCH 064/204] MOSIP-29079 --- .../DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml | 2 +- .../deleteSpecificDocForaPRIDResult.hbs | 2 +- .../GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml | 1 - 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml index 6a7e7387e04..5f970fe5d40 100644 --- a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml +++ b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml @@ -4,7 +4,7 @@ DeleteSpecificDocForaPRID: role: batch restMethod: post inputTemplate: preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRID - outputTemplate: preReg/error + outputTemplate: preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult input: '{ "preRegistrationId": "$ID:CreatePrereg_All_Valid_Smoke_sid_preRegistrationId$", "documentId": "$ID:UploadDocument_All_Valid_Smoke_sid_docId$" diff --git a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs index 64f922ef845..276349a447b 100644 --- a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs @@ -5,5 +5,5 @@ "response": { "message": "{{message}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml index 30c6c2f58da..28ecda201df 100644 --- a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml +++ b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml @@ -10,7 +10,6 @@ GetSpecificDocumentforaPRID: "documentId": "$ID:UploadDocument_All_Valid_Smoke_sid_docId$" }' output: '{ - "document": "$IGNORE$" }' Prereg_GetSpecificDocumentforaPRID_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/documents/{documentId}?preRegistrationId={preRegistrationId} From f2259fbb8735931b87aac656200c286f973fc5aa Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 14:01:09 +0530 Subject: [PATCH 065/204] MOSIP-28895 --- .../resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml | 2 +- .../GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml index 931e31936c0..43f8b40180f 100644 --- a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml +++ b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml @@ -172,7 +172,7 @@ UpdateVidStatus: role: idrepo restMethod: PATCH inputTemplate: idRepository/UpdateVIDStatus/updateVidStatus - outputTemplate: idRepository/error + outputTemplate: idRepository/UpdateVIDStatus/UpdateVidStatusResult input: '{ "vidStatus": "USED", "id": "mosip.vid.update", diff --git a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml index 28ecda201df..a0698888081 100644 --- a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml +++ b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml @@ -2,6 +2,7 @@ GetSpecificDocumentforaPRID: Prereg_GetSpecificDocumentforaPRID_All_Valid_Smoke_sid: endPoint: /preregistration/v1/documents/{documentId}?preRegistrationId={preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/GetSpecificDocumentforaPRID/getSpecificDocumentforaPRID outputTemplate: preReg/GetSpecificDocumentforaPRID/getSpecificDocumentforaPRIDResult From c70829023ebb855cf6c071005c689573c4d5ee0d Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 14:23:52 +0530 Subject: [PATCH 066/204] MOSIP-28889 --- .../SearchBlockListedWords.yml | 4 ++ .../SearchMachine/SearchMachine.yml | 64 +++++++++++++++++++ 2 files changed, 68 insertions(+) diff --git a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml index 4dcd34f0058..41968337461 100644 --- a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml @@ -30,6 +30,7 @@ SearchBlockListedWords: output: '{ "data": [ { + "isActive": "$IGNORE$", "description": "$IGNORE$", "word": "dumbo7", "langCode": "eng" @@ -67,6 +68,7 @@ SearchBlockListedWords: output: '{ "data": [ { + "isActive": "$IGNORE$", "description": "$IGNORE$", "word": "dumbo7", "langCode": "eng" @@ -104,6 +106,7 @@ SearchBlockListedWords: output: '{ "data": [ { + "isActive": "$IGNORE$", "description": "$IGNORE$", "word": "dumbo7", "langCode": "eng" @@ -177,6 +180,7 @@ SearchBlockListedWords: output: '{ "data": [ { + "isActive": "$IGNORE$", "description": "$IGNORE$", "word": "dumb7", "langCode": "eng" diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml index ee70058aa49..095fcd2261d 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml @@ -28,6 +28,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -38,6 +40,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_FilterTypeContains: endPoint: /v1/masterdata/machines/search @@ -68,6 +72,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -78,6 +84,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_FilterTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -108,6 +116,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "NLT updated", "serialNum": "FB5962911687", @@ -118,6 +128,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNFilterTypeEquals: endPoint: /v1/masterdata/machines/search @@ -148,6 +160,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -158,6 +172,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNTypeContains: endPoint: /v1/masterdata/machines/search @@ -188,6 +204,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -198,6 +216,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -228,6 +248,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -238,6 +260,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeEquals: endPoint: /v1/masterdata/machines/search @@ -268,6 +292,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -278,6 +304,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeContains: endPoint: /v1/masterdata/machines/search @@ -308,6 +336,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -318,6 +348,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -348,6 +380,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -358,6 +392,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeEquals: endPoint: /v1/masterdata/machines/search @@ -388,6 +424,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -398,6 +436,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeContains: endPoint: /v1/masterdata/machines/search @@ -428,6 +468,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -438,6 +480,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -468,6 +512,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -478,6 +524,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_TwoFilterValues_TypeEqualsNEquals: endPoint: /v1/masterdata/machines/search @@ -515,6 +563,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -525,6 +575,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_SortFieldDESC: endPoint: /v1/masterdata/machines/search @@ -555,6 +607,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -565,6 +619,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_TwoSortFields_DescNDesc: endPoint: /v1/masterdata/machines/search @@ -599,6 +655,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -609,6 +667,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Valid_TwoSortFields_AscNDesc: endPoint: /v1/masterdata/machines/search @@ -643,6 +703,8 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [ + { "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -653,6 +715,8 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": "$IGNORE$" + } + ] }' Masterdata_SearchMachine_Invalid_ColumnName: endPoint: /v1/masterdata/machines/search From f0213e80373c6d2239b51e0dd0e082b0f86083b1 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 24 Aug 2023 17:33:04 +0530 Subject: [PATCH 067/204] MOSIP-29084 --- .../ida/AddIdentity/addIdentityResult.hbs | 5 +- .../ida/AuthInternalLock/AuthInternalLock.yml | 5 +- .../authInternalLockResult.hbs | 7 +- .../resources/ida/AuthLock/createAuthLock.yml | 8 +- .../ida/AuthLock/createAuthLockResult.hbs | 8 +- .../AuthTransaction/authTransactionResult.hbs | 13 +- .../ida/AuthUnLock/createAuthUnLockResult.hbs | 8 +- .../main/resources/ida/BioAuth/BioAuth.yml | 3 +- .../resources/ida/BioAuth/BioAuthResult.hbs | 10 +- .../BlockHotlistAPI/blockHotlistAPIResult.hbs | 14 +- .../ida/CreateVID/createVidResult.hbs | 12 +- .../main/resources/ida/DemoAuth/DemoAuth.yml | 80 +-- .../resources/ida/DemoAuth/DemoAuthResult.hbs | 10 +- .../src/main/resources/ida/DemoAuth/error.hbs | 11 +- .../main/resources/ida/EkycBio/EkycBio.yml | 79 ++- .../resources/ida/EkycBio/EkycBioResult.hbs | 13 +- .../resources/ida/EkycDemo/EkycDemoResult.hbs | 13 +- .../resources/ida/EkycOtp/EkycOtpResult.hbs | 14 +- .../src/main/resources/ida/EkycOtp/error.hbs | 7 +- .../main/resources/ida/EkycOtp/sendOtpRes.hbs | 3 - .../GenerateVID/createGenerateVIDResult.hbs | 3 - .../ida/HotlistTestcases/ekycDemoResult.hbs | 9 +- .../resources/ida/HotlistTestcases/error.hbs | 11 +- .../ida/MultiFactorAuth/MultiFactorAuth.yml | 488 ++++++------------ .../ida/MultiFactorAuth/sendOtpRes.hbs | 1 - .../main/resources/ida/OtpAuth/OtpAuth.yml | 164 ++---- .../resources/ida/OtpAuth/OtpAuthResult.hbs | 10 +- .../main/resources/ida/OtpAuth/sendOtpRes.hbs | 6 - .../ida/SendOTP/createSendOTPResult.hbs | 8 +- .../UnblockHotlistAPIResult.hbs | 9 +- .../ida/UpdateIdentity/sendOtpRes.hbs | 1 - 31 files changed, 280 insertions(+), 753 deletions(-) diff --git a/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs index f972c850e57..daf815d699f 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs @@ -1,10 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, + } "errors": [ ] diff --git a/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml b/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml index 93898d64297..2cf3b769d46 100644 --- a/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml +++ b/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml @@ -14,7 +14,6 @@ AuthInternalLock: "unlockForSeconds": 500 }' output: '{ - "responsetime": "$IGNORE$" }' auth_AuthInternal_Lock_UIN_Unlock_DemoAuth_Smoke_Pos: @@ -122,7 +121,7 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "responsetime": "$IGNORE$" + "message": "$IGNORE$" }' auth_AuthInternal_Permanent_Lock_DemoAuth_Valid_Smoke_Pos: @@ -140,5 +139,5 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "responsetime": "$IGNORE$" + "message": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs b/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs index a479056eefc..08de5cbd505 100644 --- a/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs +++ b/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml index f4ed01c494f..2fae8d61174 100644 --- a/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml @@ -24,12 +24,10 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX8531", - "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" } }' auth_AuthLock_Valid_UIN_for_bio_auth: @@ -57,11 +55,9 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX8531", - "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthLock/createAuthLockResult.hbs b/automationtests/src/main/resources/ida/AuthLock/createAuthLockResult.hbs index 2dfc65607e0..08de5cbd505 100644 --- a/automationtests/src/main/resources/ida/AuthLock/createAuthLockResult.hbs +++ b/automationtests/src/main/resources/ida/AuthLock/createAuthLockResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "$IGNORE$", "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthTransaction/authTransactionResult.hbs b/automationtests/src/main/resources/ida/AuthTransaction/authTransactionResult.hbs index cbb90b4fb68..a1bfefb19a1 100644 --- a/automationtests/src/main/resources/ida/AuthTransaction/authTransactionResult.hbs +++ b/automationtests/src/main/resources/ida/AuthTransaction/authTransactionResult.hbs @@ -1,24 +1,13 @@ { - "id": null, - "version": null, - "errors": null, "response": { "authTransactions": [ {{#each authTransactions}} { "transactionID": "{{code}}", - "requestdatetime": "$IGNORE$", - "authtypeCode": "$IGNORE$", - "statusCode": "$IGNORE$", - "statusComment": "$IGNORE$", - "referenceIdType": "{{referenceIdType}}", - "entityName": "$IGNORE$", - "requestSignature": "$IGNORE$", - "responseSignature": "$IGNORE$" + "referenceIdType": "{{referenceIdType}}" } {{#unless @last}},{{/unless}} {{/each}}, ] }, - "responseTime": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLockResult.hbs b/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLockResult.hbs index 2dfc65607e0..08de5cbd505 100644 --- a/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLockResult.hbs +++ b/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLockResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "$IGNORE$", "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml index 45ead6e8df5..7c79d395d26 100644 --- a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml +++ b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml @@ -789,8 +789,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - request/biometrics/0/data/bioSubType - dh363737dbsb" + "errorCode": "IDA-MLC-009" } ], "authStatus": false diff --git a/automationtests/src/main/resources/ida/BioAuth/BioAuthResult.hbs b/automationtests/src/main/resources/ida/BioAuth/BioAuthResult.hbs index fe1436c61c0..1c86da21a83 100644 --- a/automationtests/src/main/resources/ida/BioAuth/BioAuthResult.hbs +++ b/automationtests/src/main/resources/ida/BioAuth/BioAuthResult.hbs @@ -1,16 +1,8 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { - "signature": "$IGNORE$", "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "authStatus": "{{authStatus}}", - "authToken": "$IGNORE$" + "authStatus": "{{authStatus}}" } } } diff --git a/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPIResult.hbs b/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPIResult.hbs index f6a41e7a7c3..ca45b742b9e 100644 --- a/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPIResult.hbs +++ b/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPIResult.hbs @@ -1,15 +1,5 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "id": "$IGNORE$", - "idType": "$IGNORE$", - "status": "{{status}}", - "expiryTimestamp": "$IGNORE$" - }, - "errors": [ - - ] + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs b/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs index 1fc2e60613e..5e95428a4f1 100644 --- a/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs +++ b/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs @@ -1,13 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "vidStatus": "{{vidStatus}}", - "restoredVid": "$IGNORE$", - "UIN": "$IGNORE$", - "VID": "$IGNORE$" - }, - "errors": [] + "vidStatus": "{{vidStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index b4d64efd194..a324d4eefcd 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -51,10 +51,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-MLC-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-001" } - ], + ] "authStatus": "false" }' @@ -73,10 +72,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-MLC-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-001" } - ], + ] "authStatus": "false" }' @@ -95,10 +93,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-MLC-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-001" } - ], + ] "authStatus": "false" }' @@ -118,8 +115,7 @@ DemoAuthNew: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - request/demographics/dob" + "errorCode": "IDA-MLC-009" } ] }' @@ -139,8 +135,7 @@ DemoAuthNew: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - request/demographics/dob" + "errorCode": "IDA-MLC-009" } ] }' @@ -175,10 +170,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-MLC-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-001" } - ], + ] "authStatus": "false" }' @@ -197,10 +191,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-MLC-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-001" } - ], + ] "authStatus": "false" }' @@ -235,8 +228,7 @@ DemoAuthNew: "authStatus": false, "errors": [ { - "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data emailId did not match" + "errorCode": "IDA-DEA-001" } ] }' @@ -256,8 +248,7 @@ DemoAuthNew: "authStatus": false, "errors": [ { - "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data emailId did not match" + "errorCode": "IDA-DEA-001" } ] }' @@ -318,11 +309,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-DEA-001", - "errorMessage": "$IGNORE$", - "actionMessage": "Please re-enter your gender in eng" + "errorCode": "IDA-DEA-001" } - ], + ] "authStatus": false }' auth_DemoAuth_InValid_uin_gender: @@ -344,11 +333,9 @@ DemoAuthNew: output: '{ "errors": [ { - "errorCode": "IDA-DEA-001", - "errorMessage": "$IGNORE$", - "actionMessage": "Please re-enter your gender in eng" + "errorCode": "IDA-DEA-001" } - ], + ] "authStatus": false }' auth_DemoAuth_Name_Valid_uin_Smoke_Pos: @@ -542,7 +529,6 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "$IGNORE$", "actionMessage": "Please re-enter your name in eng" } ], @@ -568,7 +554,6 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "$IGNORE$", "actionMessage": "Please re-enter your name in eng" } ], @@ -677,7 +662,6 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data phoneNumber did not match", "actionMessage": "Please re-enter your phoneNumber" } ], @@ -699,7 +683,6 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data phoneNumber did not match", "actionMessage": "Please re-enter your phoneNumber" } ], @@ -736,9 +719,8 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" } - ], + ] "authStatus": false }' auth_DemoAuth_DOB_Missing_individualId: @@ -757,9 +739,8 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" } - ], + ] "authStatus": false }' auth_DemoAuth_DOB_Blank_individualId: @@ -778,9 +759,8 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" } - ], + ] "authStatus": false }' auth_DemoAuth_DOB_Invalid_transactionId_uin_Neg: @@ -829,9 +809,8 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-019", - "errorMessage": "demo Auth Type is Locked for the UIN" } - ], + ] "authStatus": false }' @@ -851,9 +830,8 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-019", - "errorMessage": "demo Auth Type is Locked for the UIN" } - ], + ] "authStatus": false }' auth_DemoAuth_revoke_vid_Pos: @@ -872,8 +850,7 @@ DemoAuthNew: "authStatus": "false", "errors": [ { - "errorCode": "IDA-MLC-018", - "errorMessage": "VID not available in database" + "errorCode": "IDA-MLC-018" } ] }' @@ -893,8 +870,7 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" - }, + } { "errorCode": "IDA-MPA-009", "errorMessage": "Partner is not registered" @@ -919,9 +895,8 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-019", - "errorMessage": "demo Auth Type is Locked for the UIN" } - ], + ] "authStatus": false }' @@ -941,8 +916,7 @@ DemoAuthNew: "errors": [ { "errorCode": "IDA-MLC-019", - "errorMessage": "demo Auth Type is Locked for the UIN" } - ], + ] "authStatus": false }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuthResult.hbs b/automationtests/src/main/resources/ida/DemoAuth/DemoAuthResult.hbs index fe1436c61c0..1c86da21a83 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuthResult.hbs +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuthResult.hbs @@ -1,16 +1,8 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { - "signature": "$IGNORE$", "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "authStatus": "{{authStatus}}", - "authToken": "$IGNORE$" + "authStatus": "{{authStatus}}" } } } diff --git a/automationtests/src/main/resources/ida/DemoAuth/error.hbs b/automationtests/src/main/resources/ida/DemoAuth/error.hbs index c2baf409f29..d81bef285c1 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/error.hbs +++ b/automationtests/src/main/resources/ida/DemoAuth/error.hbs @@ -1,22 +1,15 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", "errors": [ {{#each errors}} { "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}", - "actionMessage": "$IGNORE$" + "errorMessage": "{{errorMessage}}" } {{#unless @last}},{{/unless}} {{/each}} - ], - "responseTime": "$IGNORE$", + ] "response": { "authStatus": {{authStatus}} } diff --git a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml index a601d511983..6ba711f9db4 100644 --- a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml +++ b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml @@ -867,10 +867,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-018", - "errorMessage": "VID not available in database" + "errorCode": "IDA-MLC-018" } - ], + ] "kycStatus": false }' auth_EkycBio_invalid_uin_bioSubType: @@ -901,10 +900,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - request/biometrics/0/data/bioSubType - L@@@$%4556eft" + "errorCode": "IDA-MLC-009" } - ], + ] "kycStatus": false }' auth_EkycBio_invalid_bioSubType_VID: @@ -935,10 +933,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - request/biometrics/0/data/bioSubType - L@@@$%4556eft" - } - ], + "errorCode": "IDA-MLC-009" +} + ] "kycStatus": false }' auth_EkycBio_blank_uin_bioSubType: @@ -969,10 +966,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioSubType" + "errorCode": "IDA-MLC-006" } - ], + ] "kycStatus": false }' auth_EkycBio_blank_bioSubType_VID: @@ -1003,10 +999,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioSubType" + "errorCode": "IDA-MLC-006" } - ], + ] "kycStatus": false }' auth_EkycBio_Blank_uin_bioType: @@ -1037,10 +1032,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioType" + "errorCode": "IDA-MLC-006" } - ], + ] "kycStatus": false }' auth_EkycBio_Blank_bioType_VID: @@ -1071,10 +1065,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioType" + "errorCode": "IDA-MLC-006" } - ], + ] "kycStatus": false }' auth_EkycBio_Invalid_uin_bioType: @@ -1105,11 +1098,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-ddff3355", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } - ], + ] "kycStatus": false }' auth_EkycBio_Invalid_bioType_VID: @@ -1140,11 +1131,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-ddff3355", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } - ], + ] "kycStatus": false }' auth_EkycBio_Iris_With_FaceBio_uin_Invalid: @@ -1175,11 +1164,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - Iris did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } - ], + ] "kycStatus": false }' auth_EkycBio_Iris_With_FaceBio_Invalid_VID: @@ -1210,11 +1197,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - Iris did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } - ], + ] "kycStatus": false }' auth_EkycBio_Finger_With_FaceBio_uin_Invalid: @@ -1245,11 +1230,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - Finger did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } - ], + ] "kycStatus": false }' auth_EkycBio_Finger_With_FaceBio_Invalid_VID: @@ -1280,11 +1263,9 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - Finger did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } - ], + ] "kycStatus": false }' auth_EkycBio_Finger_With_dummy_partnerkey_Pos_vid: @@ -1315,13 +1296,11 @@ EkycBio: output: '{ "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" + "errorCode": "IDA-MLC-007" }, { "errorCode": "IDA-MPA-009", - "errorMessage": "Partner is not registered" } - ], + ] "kycStatus": false }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/EkycBio/EkycBioResult.hbs b/automationtests/src/main/resources/ida/EkycBio/EkycBioResult.hbs index 635e18f40f8..9d51fe4b7fb 100644 --- a/automationtests/src/main/resources/ida/EkycBio/EkycBioResult.hbs +++ b/automationtests/src/main/resources/ida/EkycBio/EkycBioResult.hbs @@ -1,19 +1,8 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { - "signature": "$IGNORE$", "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "kycStatus": {{kycStatus}}, - "authToken": "$IGNORE$", - "thumbprint": "$IGNORE$", - "identity": "$IGNORE$", - "sessionKey": "$IGNORE$" + "kycStatus": {{kycStatus}} } } } diff --git a/automationtests/src/main/resources/ida/EkycDemo/EkycDemoResult.hbs b/automationtests/src/main/resources/ida/EkycDemo/EkycDemoResult.hbs index 635e18f40f8..9d51fe4b7fb 100644 --- a/automationtests/src/main/resources/ida/EkycDemo/EkycDemoResult.hbs +++ b/automationtests/src/main/resources/ida/EkycDemo/EkycDemoResult.hbs @@ -1,19 +1,8 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { - "signature": "$IGNORE$", "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "kycStatus": {{kycStatus}}, - "authToken": "$IGNORE$", - "thumbprint": "$IGNORE$", - "identity": "$IGNORE$", - "sessionKey": "$IGNORE$" + "kycStatus": {{kycStatus}} } } } diff --git a/automationtests/src/main/resources/ida/EkycOtp/EkycOtpResult.hbs b/automationtests/src/main/resources/ida/EkycOtp/EkycOtpResult.hbs index f1d1610b372..9d51fe4b7fb 100644 --- a/automationtests/src/main/resources/ida/EkycOtp/EkycOtpResult.hbs +++ b/automationtests/src/main/resources/ida/EkycOtp/EkycOtpResult.hbs @@ -1,20 +1,8 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { - "signature": "$IGNORE$", "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "authStatus": "$IGNORE$", - "kycStatus": {{kycStatus}}, - "authToken": "$IGNORE$", - "thumbprint": "$IGNORE$", - "identity": "$IGNORE$", - "sessionKey": "$IGNORE$" + "kycStatus": {{kycStatus}} } } } diff --git a/automationtests/src/main/resources/ida/EkycOtp/error.hbs b/automationtests/src/main/resources/ida/EkycOtp/error.hbs index dc897c9c9df..ef259195be1 100644 --- a/automationtests/src/main/resources/ida/EkycOtp/error.hbs +++ b/automationtests/src/main/resources/ida/EkycOtp/error.hbs @@ -1,19 +1,14 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { "body": { "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}", - "actionMessage": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} ], - "responseTime": "$IGNORE$", "response": { "kycStatus": {{kycStatus}} } diff --git a/automationtests/src/main/resources/ida/EkycOtp/sendOtpRes.hbs b/automationtests/src/main/resources/ida/EkycOtp/sendOtpRes.hbs index 783fd988be7..2913bf11b3d 100644 --- a/automationtests/src/main/resources/ida/EkycOtp/sendOtpRes.hbs +++ b/automationtests/src/main/resources/ida/EkycOtp/sendOtpRes.hbs @@ -1,8 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", "transactionID": "{{transactionID}}", - "responseTime": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" diff --git a/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs index 11ae4e88d64..1014506179d 100644 --- a/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs @@ -1,7 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "vid": "{{vid}}", "message": "{{message}}" diff --git a/automationtests/src/main/resources/ida/HotlistTestcases/ekycDemoResult.hbs b/automationtests/src/main/resources/ida/HotlistTestcases/ekycDemoResult.hbs index 348b66ca990..e6b2c5b20d9 100644 --- a/automationtests/src/main/resources/ida/HotlistTestcases/ekycDemoResult.hbs +++ b/automationtests/src/main/resources/ida/HotlistTestcases/ekycDemoResult.hbs @@ -1,12 +1,5 @@ { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "kycStatus": "{{kycStatus}}", - "authToken": "$IGNORE$", - "thumbprint": "$IGNORE$", - "identity": "$IGNORE$" + "kycStatus": "{{kycStatus}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/HotlistTestcases/error.hbs b/automationtests/src/main/resources/ida/HotlistTestcases/error.hbs index 614cd8ec59f..ea4e6bc62fb 100644 --- a/automationtests/src/main/resources/ida/HotlistTestcases/error.hbs +++ b/automationtests/src/main/resources/ida/HotlistTestcases/error.hbs @@ -1,20 +1,13 @@ { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}", - "actionMessage": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} ], - "responseTime": "$IGNORE$", "response": { - "authStatus": {{authStatus}}, - "authToken": "$IGNORE$" + "authStatus": {{authStatus}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml index 89dbb1ede59..69a981cb2ef 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml @@ -32,10 +32,7 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_InValid_transactionId_uin_Neg: @@ -71,10 +68,7 @@ MultiFactorAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_Missing_transactionId_uin_Neg: @@ -110,10 +104,7 @@ MultiFactorAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_Valid_vid_Smoke_Pos: @@ -149,10 +140,7 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_revoked_vid: @@ -194,10 +182,7 @@ MultiFactorAuth: } ], "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_InValid_vid_transactionId_Neg: @@ -233,10 +218,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_blank_vid_transactionId_Neg: @@ -272,10 +254,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RingFinger_With_Valid_uin_Smoke_Pos: @@ -311,10 +290,7 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RingFinger_With_missing_transactionId_uin_Neg: @@ -350,10 +326,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RingFinger_With_invalid_transactionId_uin_Neg: @@ -389,10 +362,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RingFinger_With_vid_InValid_transactionId_Neg: @@ -427,10 +397,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RingFinger_With_vid_blank_transactionId_Neg: @@ -466,10 +433,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RingFinger_With_Valid_VID_Smoke_Pos: @@ -505,10 +469,7 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_uin_Valid_Smoke_Pos: @@ -544,10 +505,7 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_uin_InValid_transactionId_Neg: @@ -583,10 +541,7 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_uin_blank_transactionId_Neg: @@ -622,10 +577,8 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_Valid_VID_Smoke_Pos: @@ -661,10 +614,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIndexFingerr_With_uin_Valid_Smoke_Pos: @@ -700,10 +651,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + " + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIndexFingerr_With_Valid_vid_Smoke_Pos: @@ -739,10 +688,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftLittleFinger_With_uin_Valid_Smoke_Pos: @@ -778,10 +725,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftLittleFinger_With_Valid_VID_Smoke_Pos: @@ -817,10 +762,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightIndexFinger_With_uin_Valid_Smoke_Pos: @@ -856,10 +799,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightIndexFinger_With_Valid_VID_Smoke_Pos: @@ -895,10 +836,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightRingFinger_With_uin_Valid_Smoke_Pos: @@ -934,10 +873,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightRingFinger_With_Valid_VID_Smoke_Pos: @@ -973,10 +910,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + " + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightMiddleFinger_With_uin_Valid_Smoke_Pos: @@ -1012,10 +947,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightMiddleFinger_With_Valid_VID_Smoke_Pos: @@ -1051,10 +984,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightLittleFinger_With_uin_Valid_Smoke_Pos: @@ -1090,10 +1021,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightLittleFinger_With_Valid_VID_Smoke_Pos: @@ -1129,10 +1058,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftThumb_With_uin_Valid_Smoke_Pos: @@ -1168,10 +1095,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftThumb_With_Valid_VID_Smoke_Pos: @@ -1207,10 +1132,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightThumb_With_Valid_uin_Smoke_Pos: @@ -1246,10 +1169,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightThumb_With_Valid_VID_Smoke_Pos: @@ -1285,10 +1206,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightIris_With_uin_Valid_Smoke_Pos: @@ -1324,10 +1243,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_RightIris_With_Valid_VID_Smoke_Pos: @@ -1363,10 +1280,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_uin_Valid_Smoke_Pos: @@ -1402,10 +1317,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With__VID_Valid_Smoke_Pos: @@ -1441,10 +1354,8 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_InValid_transactionId_Neg: @@ -1480,10 +1391,8 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_InValid_transactionId_Neg: @@ -1519,10 +1428,8 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_blank_transactionId_Neg: @@ -1558,10 +1465,8 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_uin_blank_transactionId_Neg: @@ -1597,10 +1502,8 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_blank_individualIdType_Pos: @@ -1636,10 +1539,8 @@ MultiFactorAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_individualIdType_Pos: @@ -1675,10 +1576,8 @@ MultiFactorAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_bioSubType: @@ -1715,15 +1614,11 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_bioSubType: @@ -1760,15 +1655,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_blank_bioSubType: @@ -1805,15 +1697,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioSubType" + "errorCode": "IDA-MLC-006" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_blank_bioSubType: @@ -1850,15 +1739,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioSubType" + "errorCode": "IDA-MLC-006" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_missing_bioSubType_Neg: @@ -1896,14 +1782,12 @@ MultiFactorAuth: "errors": [ { "errorCode": "IDA-MLC-006", - "errorMessage": "$IGNORE$" + } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_missing_bioSubType: @@ -1940,15 +1824,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-006" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_BLANK_bioType: @@ -1985,10 +1866,8 @@ MultiFactorAuth: "authStatus": "$IGNORE$", "errors": "$IGNORE$", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_BLANK_bioType: @@ -2025,15 +1904,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioType" + "errorCode": "IDA-MLC-006" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_missing_bioType: @@ -2070,15 +1946,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-011" } ], "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_bioType: @@ -2115,15 +1988,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-011" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_valid_bioType_and_invalid_digitalId_type: @@ -2160,19 +2030,14 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" - }, + "errorCode": "IDA-MLC-007" + } { - "errorCode": "IDA-DPM-004", - "errorMessage": "Device Type and Biometric Type do not match" + "errorCode": "IDA-DPM-004" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_valid_bioType_and_invalid_digitalId_type: @@ -2209,19 +2074,14 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" - }, + "errorCode": "IDA-MLC-007" + } { - "errorCode": "IDA-DPM-004", - "errorMessage": "Device Type and Biometric Type do not match" + "errorCode": "IDA-DPM-004" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_INvalid_bioValue: @@ -2258,15 +2118,11 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-BIA-001" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_INvalid_bioValue: @@ -2303,15 +2159,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-BIA-001" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_With_Face_Invalid: @@ -2348,15 +2201,11 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-BIA-001" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_With_Face_Invalid: @@ -2394,14 +2243,12 @@ MultiFactorAuth: "errors": [ { "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$" + "errorMessage": "$IGNORE$ } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_With_Finger_Invalid: @@ -2438,15 +2285,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-BIA-001" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_With_Finger_Invalid: @@ -2483,15 +2327,11 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-BIA-001" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_Bio-Type_value_as_IR_instead_of_Iris: @@ -2528,15 +2368,11 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-011" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_Bio-Type_value_as_IR_instead_of_Iris: @@ -2573,15 +2409,12 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-011" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_With_VID_invalid_Bio-Type_value_as_FIR_instead_of_Finger: @@ -2619,14 +2452,10 @@ MultiFactorAuth: "errors": [ { "errorCode": "IDA-MLC-011", - "errorMessage": "$IGNORE$" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_With_UIN_invalid_Bio-Type_value_as_FIR_instead_of_Finger: @@ -2663,15 +2492,11 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-011" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_MultiFactorAuth_with_uin_invalid_partner: @@ -2708,18 +2533,13 @@ MultiFactorAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" + "errorCode": "IDA-MLC-007" }, { - "errorCode": "IDA-MPA-009", - "errorMessage": "Partner is not registered" + "errorCode": "IDA-MPA-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs b/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs index e8f25e73ee1..8703038601e 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs @@ -2,7 +2,6 @@ "id": "mosip.identity.otp", "version": "1.0", "transactionID": "{{transactionID}}", - "responseTime": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml index 1925587a476..fe126f671f2 100644 --- a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml @@ -15,10 +15,7 @@ OtpAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -38,10 +35,7 @@ OtpAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -61,10 +55,7 @@ OtpAuth: output: '{ "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -84,10 +75,7 @@ OtpAuth: output: '{ "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -107,10 +95,7 @@ OtpAuth: output: '{ "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -130,10 +115,7 @@ OtpAuth: output: '{ "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -153,10 +135,7 @@ OtpAuth: output: '{ "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -176,10 +155,7 @@ OtpAuth: output: '{ "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -199,17 +175,12 @@ OtpAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-018", - "errorMessage": "VID not available in database", - "actionMessage": "$IGNORE$" + "errorCode": "IDA-MLC-018" } - ], + ] "authStatus": "false", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Invalid_individualId_UIN_neg: @@ -229,15 +200,11 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Invalid_individualId_VID_neg: @@ -257,15 +224,11 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Blank_individualId_uin_neg: @@ -285,15 +248,11 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Blank_individualId_VID_neg: @@ -313,15 +272,11 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Missing_individualId_uin_neg: @@ -341,15 +296,11 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" + "errorCode": "IDA-MLC-009" } ], "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Missing_individualId_VID_neg: @@ -369,15 +320,11 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-009", - "errorMessage": "Invalid Input Parameter - individualId" + "errorCode": "IDA-MLC-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Invalid_transactionId_uin_Neg: @@ -396,10 +343,7 @@ OtpAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Invalid_transactionId_VID_Neg: @@ -418,10 +362,7 @@ OtpAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Blank_transactionId_uin_Neg: @@ -440,10 +381,7 @@ OtpAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Blank_transactionId_VID_Neg: @@ -462,10 +400,8 @@ OtpAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_different_transactionId_uin_neg: @@ -484,10 +420,8 @@ OtpAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Invalid_individualIdType_VID_neg: @@ -506,10 +440,7 @@ OtpAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Blank_individualIdType_VID_Pos: @@ -528,10 +459,7 @@ OtpAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Missing_Optional_Field_individualIdType_VID: @@ -550,10 +478,7 @@ OtpAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' auth_OTP_Auth_With_Invalid_uin_partner: @@ -573,18 +498,13 @@ OtpAuth: "authStatus": false, "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" + "errorCode": "IDA-MLC-007" }, { - "errorCode": "IDA-MPA-009", - "errorMessage": "Partner is not registered" + "errorCode": "IDA-MPA-009" } - ], + ] "sendOtpResp":{ - "transactionID": "$IGNORE$", - "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuthResult.hbs b/automationtests/src/main/resources/ida/OtpAuth/OtpAuthResult.hbs index fe1436c61c0..1c86da21a83 100644 --- a/automationtests/src/main/resources/ida/OtpAuth/OtpAuthResult.hbs +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuthResult.hbs @@ -1,16 +1,8 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { - "signature": "$IGNORE$", "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "authStatus": "{{authStatus}}", - "authToken": "$IGNORE$" + "authStatus": "{{authStatus}}" } } } diff --git a/automationtests/src/main/resources/ida/OtpAuth/sendOtpRes.hbs b/automationtests/src/main/resources/ida/OtpAuth/sendOtpRes.hbs index 783fd988be7..51a54105dc5 100644 --- a/automationtests/src/main/resources/ida/OtpAuth/sendOtpRes.hbs +++ b/automationtests/src/main/resources/ida/OtpAuth/sendOtpRes.hbs @@ -1,10 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "transactionID": "{{transactionID}}", - "responseTime": "$IGNORE$", "response": { - "maskedMobile": "{{maskedMobile}}", - "maskedEmail": "{{maskedEmail}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs index 0668a51b54b..763f9934fe8 100644 --- a/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs @@ -1,12 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnblockHotlistAPIResult.hbs b/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnblockHotlistAPIResult.hbs index f6a41e7a7c3..f5369a76ae2 100644 --- a/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnblockHotlistAPIResult.hbs +++ b/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnblockHotlistAPIResult.hbs @@ -1,13 +1,6 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "id": "$IGNORE$", - "idType": "$IGNORE$", - "status": "{{status}}", - "expiryTimestamp": "$IGNORE$" + "status": "{{status}}" }, "errors": [ diff --git a/automationtests/src/main/resources/ida/UpdateIdentity/sendOtpRes.hbs b/automationtests/src/main/resources/ida/UpdateIdentity/sendOtpRes.hbs index e8f25e73ee1..8703038601e 100644 --- a/automationtests/src/main/resources/ida/UpdateIdentity/sendOtpRes.hbs +++ b/automationtests/src/main/resources/ida/UpdateIdentity/sendOtpRes.hbs @@ -2,7 +2,6 @@ "id": "mosip.identity.otp", "version": "1.0", "transactionID": "{{transactionID}}", - "responseTime": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" From 90d4b67a6904af2dba8a96954b8d0859020940cd Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 24 Aug 2023 18:32:52 +0530 Subject: [PATCH 068/204] MOSIP-29084 --- .../src/main/resources/ida/AddIdentity/addIdentityResult.hbs | 3 --- 1 file changed, 3 deletions(-) diff --git a/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs index daf815d699f..ca45b742b9e 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs @@ -2,7 +2,4 @@ "response": { "status": "{{status}}" } - "errors": [ - - ] } \ No newline at end of file From f5a3cb5ef2e96aced737c6cc2ac0ee81c31c6bbc Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 24 Aug 2023 19:40:17 +0530 Subject: [PATCH 069/204] MOSIP-29064 --- .../apirig/testrunner/ExtractResource.java | 38 +++- .../BiometricAttributes.yml | 5 +- .../biometricAttributesResult.hbs | 3 - .../blockListedWordValidationResult.hbs | 7 +- .../UpdateBlockListedWords.yml | 6 +- .../blockListedWordsResult.hbs | 7 +- .../masterdata/BulkUpload/BulkUpload.yml | 1 - .../BulkUpload/bulkUploadResult.hbs | 17 +- .../createApplicationTypeResult.hbs | 7 +- .../createBiometricTypeResult.hbs | 7 +- .../CreateIdType/createIdTypeResult.hbs | 7 +- .../DecommisionDevice/decommisionDevice.yml | 3 +- .../decommisionDeviceResult.hbs | 11 +- .../decommisionMachineResult.hbs | 7 +- .../DecommissionRegCenter.yml | 1 - .../decommissionRegCenterResult.hbs | 7 +- .../deleteBlockListedWordsResult.hbs | 7 +- .../masterdata/DeleteDevice/deleteDevice.yml | 1 + .../DeleteDevice/deleteDeviceResult.hbs | 7 +- .../deleteDeviceSpecResult.hbs | 11 +- .../deleteDocumentCategoryResult.hbs | 7 +- .../deleteDocumentTypeResult.hbs | 7 +- .../deleteDynamicFieldResult.hbs | 7 +- .../DeleteGenderType/DeleteGenderType.yml | 1 - .../deleteGenderTypeResult.hbs | 7 +- .../DeleteHoliday/deleteHolidayResult.hbs | 7 +- .../DeleteLanguage/deleteLanguageResult.hbs | 6 - .../DeleteLocation/deleteLocationResult.hbs | 7 +- .../DeleteMachine/deleteMachineResult.hbs | 11 +- .../deleteMachineSpecResult.hbs | 11 +- .../DeleteRegCenter/deleteRegCenterResult.hbs | 7 +- .../deleteRegCenterTypeResult.hbs | 7 +- .../DeleteTemplate/DeleteTemplate.yml | 1 - .../DeleteTemplate/deleteTemplateResult.hbs | 7 +- .../deleteTemplateFileFormatResult.hbs | 7 +- .../deleteUserCenterMappingResult.hbs | 7 +- .../deleteUserDetailsResult.hbs | 7 +- .../deleteValidDocumentResult.hbs | 7 +- .../DeleteZoneUser/deleteZoneUserResult.hbs | 7 +- .../masterdata/Device/createDeviceResult.hbs | 17 +- .../masterdata/DeviceFilter/DeviceFilter.yml | 3 +- .../DeviceFilter/deviceFilterResult.hbs | 7 +- .../masterdata/DeviceSearch/DeviceSearch.yml | 3 +- .../DeviceSearch/deviceSearchResult.hbs | 15 +- .../DeviceSpecFilter/DeviceSpecFilter.yml | 3 +- .../deviceSpecFilterResult.hbs | 7 +- .../DeviceSpecSearch/DeviceSpecSearch.yml | 18 +- .../deviceSpecSearchResult.hbs | 15 +- .../deviceSpecificationResult.hbs | 7 +- .../DeviceType/deviceTypeResult.hbs | 7 +- .../DeviceTypeFilter/DeviceTypeFilter.yml | 6 +- .../deviceTypeFilterResult.hbs | 7 +- .../DeviceTypeSearch/DeviceTypeSearch.yml | 3 +- .../deviceTypeSearchResult.hbs | 15 +- .../documentCategoryResult.hbs | 7 +- .../DocumentType/documentTypeResult.hbs | 15 +- .../DynamicField/dynamicFieldResult.hbs | 11 +- .../fetchAllBlockListedWordResult.hbs | 30 +-- .../fetchAllDeviceSpecResult.hbs | 14 +- .../fetchAllDeviceTypesResult.hbs | 31 +-- .../fetchAllDocumentCategoriesResult.hbs | 31 +-- .../fetchAllDocumentTypesResult.hbs | 31 +-- .../fetchAllHolidayResult.hbs | 21 +- .../fetchAllIdschemaResult.hbs | 31 +-- .../fetchAllLocationResult.hbs | 33 +--- .../fetchAllMachineSpecificationResult.hbs | 36 +--- .../fetchAllMachineTypeResult.hbs | 31 +-- .../FetchAllRegCent/fetchAllRegCentResult.hbs | 16 +- .../FetchAllRegCenterType.yml | 1 - .../fetchAllRegCenterTypeResult.hbs | 14 +- .../fetchAllTemplatesResult.hbs | 14 +- .../FetchAllTitle/fetchAllTitleResult.hbs | 22 +-- .../FetchAllUISpec/FetchAllUISpec.yml | 4 - .../FetchAllUISpec/fetchAllUISpecResult.hbs | 45 +---- .../fetchAllUserDetailsResult.hbs | 26 +-- .../fetchAllValidDocumentsResult.hbs | 30 +-- .../FetchAppConfig/FetchAppConfig.yml | 10 - .../FetchAppConfig/fetchAppConfigResult.hbs | 16 +- .../fetchBlockListedWordByLangcodeResult.hbs | 12 +- .../FetchDevice/fetchDeviceResult.hbs | 4 - .../FetchDeviceSpec/fetchDeviceSpecResult.hbs | 26 +-- .../fetchDistinctDynamicFieldResult.hbs | 9 +- ...chDistinctDynamicFieldByLangcodeResult.hbs | 18 +- .../fetchDocumentCategoriesResult.hbs | 10 +- .../fetchDocumentTypesResult.hbs | 10 +- .../fetchDocumentTypesbylangcodeResult.hbs | 10 +- .../fetchDynamicFieldResult.hbs | 41 +--- .../FetchGenderType/FetchGenderType.yml | 1 - .../FetchGenderType/fetchGenderTypeResult.hbs | 9 +- .../fetchGenderTypeValidationResult.hbs | 7 +- .../FetchHolidays/fetchHolidayResult.hbs | 11 +- .../FetchIdSchema/FetchIdSchema.yml | 1 - .../FetchIdSchema/fetchIdSchemaResult.hbs | 24 +-- .../fetchLocationDetailsbyLangcodeResult.hbs | 23 +-- .../fetchLocationImmediatechildrenResult.hbs | 15 +- .../FetchLocation/fetchLocationResult.hbs | 12 +- .../fetchLocationValidationResult.hbs | 7 +- .../fetchLocationHierarchyResult.hbs | 6 +- .../fetchMachineByCenterResult.hbs | 31 +-- .../FetchMissingDynamicField.yml | 2 - .../fetchMissingDynamicFieldResult.hbs | 9 +- .../FetchMissingLocation.yml | 1 - .../fetchMissingLocationResult.hbs | 9 +- .../FetchMissingRegCenterDetails.yml | 1 - .../fetchMissingRegCenterDetailsResult.hbs | 9 +- ...fetchMissingRegCenterTypeDetailsResult.hbs | 9 +- .../FetchMissingTemplates.yml | 2 - .../fetchMissingTemplatesResult.hbs | 9 +- .../masterdata/FetchModule/FetchModule.yml | 6 +- .../FetchModule/fetchModuleResult.hbs | 13 +- .../masterdata/FetchRegCent/FetchRegCent.yml | 25 +-- .../FetchRegCent/fetchAllRegCentResult.hbs | 37 +--- .../fetchAllRegCentWithPaginationResult.hbs | 53 +----- .../fetchRegCentHolidayResult.hbs | 44 +---- .../FetchRegCent/fetchRegCentResult.hbs | 28 +-- .../fetchRegCentValidateResult.hbs | 7 +- .../FetchRegCentDeviceHistory.yml | 3 +- .../fetchRegCentDeviceHistoryResult.hbs | 12 +- .../fetchRegCentHistoryResult.hbs | 25 +-- .../FetchTemplate/FetchTemplate.yml | 1 - .../FetchTemplate/fetchTemplateResult.hbs | 16 +- .../fetchTemplateTypeResult.hbs | 10 +- .../FetchTitle/fetchTitleResult.hbs | 10 +- .../masterdata/FetchUISpec/FetchUISpec.yml | 4 - .../FetchUISpec/fetchUISpecResult.hbs | 45 +---- .../fetchValidDocumentsResult.hbs | 34 +--- ...hValidDocumentsByDocCategoryCodeResult.hbs | 13 +- ...dValidDocumentsByDocCategoryCodeResult.hbs | 5 +- .../fetchWorkingDaysResult.hbs | 21 +- .../FilterBlockListedWords.yml | 3 +- .../filterBlockListedWordsResult.hbs | 7 +- .../FilterDocCategory/FilterDocCategory.yml | 3 +- .../filterDocCategoryResult.hbs | 7 +- .../filterDocumentTypeResult.hbs | 7 +- .../FilterDynamicField/FilterDynamicField.yml | 3 +- .../filterDynamicFieldResult.hbs | 7 +- .../FilterHolidays/FilterHolidays.yml | 11 +- .../FilterHolidays/filterHolidaysResult.hbs | 7 +- .../filterLocationDataResult.hbs | 7 +- .../FilterMachineSpec/FilterMachineSpec.yml | 6 +- .../filterMachineSpecResult.hbs | 7 +- .../FilterMachineType/FilterMachineType.yml | 3 +- .../filterMachineTypeResult.hbs | 7 +- .../FilterMachines/FilterMachines.yml | 3 +- .../FilterMachines/filterMachinesResult.hbs | 7 +- .../filterRegCenterTypeResult.hbs | 7 +- .../filterTemplateDetailsResult.hbs | 7 +- .../filterZoneDetailsResult.hbs | 7 +- .../masterdata/Gender/genderResult.hbs | 7 +- .../GenderFilter/genderFilterResult.hbs | 7 +- .../masterdata/GenderSearch/searchResult.hbs | 8 - .../allTxnDetailsResult.hbs | 19 +- .../getApplicantTypeResult.hbs | 7 +- .../getApplicationConfigs.yml | 4 +- .../getApplicationConfigsResult.hbs | 7 +- ...ApplicationTypeByCodeAndLangcodeResult.hbs | 12 +- .../getApplicationTypesResult.hbs | 22 +-- .../getApplicationTypesByLangcodeResult.hbs | 13 +- ...getBiometricAttributesByAuthTypeResult.hbs | 13 +- ...etBiometricTypeByCodeAndLangcodeResult.hbs | 12 +- .../getBiometricTypesResult.hbs | 22 +-- .../getBiometricTypesByLangcodeResult.hbs | 13 +- .../getDeviceHistoryNotFoundError.hbs | 1 - .../getDeviceHistoryResult.hbs | 17 +- .../GetDocCategory/getDocCategoryResult.hbs | 7 +- .../getDocCategoryByLangCodeResult.hbs | 7 +- .../getDocType_DocCatByAppIDResult.hbs | 14 +- .../getDocumentTypeByLangCodeResult.hbs | 7 +- .../getExceptionalHolidaysResult.hbs | 28 +-- .../getHolidaysMissingIdsResult.hbs | 10 +- .../getIdTypeByLangCodeResult.hbs | 7 +- .../getIndividualTypeResult.hbs | 27 +-- .../GetLanguage/getLanguageResult.hbs | 9 +- .../getLeafZonesByLangCodeResult.hbs | 19 +- .../getLeafsByLangCodeResult.hbs | 22 +-- ...LocationHierarchyByHierarchyNameResult.hbs | 9 +- ...nHierarchyLevelByLastUpdatedDateResult.hbs | 9 +- .../GetLocations/getLocationsResult.hbs | 34 +--- .../getMachineHistoryResult.hbs | 7 +- .../GetMachines/getMachinesResult.hbs | 7 +- .../getMappedMachinesByRegCentIDResult.hbs | 30 +-- ...issingDocumentCategoryByLangcodeResult.hbs | 11 +- ...getMissingDocumentTypeByLangcodeResult.hbs | 11 +- .../getModuleByIdLangCodeResult.hbs | 8 +- .../getModuleByLangCodeResult.hbs | 10 +- .../getPacketRejectionReasonResult.hbs | 35 +--- .../getPossiableValuesResult.hbs | 7 +- .../getSubZoneByLangCodeResult.hbs | 22 +-- .../getTemplateFileFormatResult.hbs | 11 +- .../GetTemplateType/templateTypeResult.hbs | 10 +- .../GetTemplateType/templateTypeResult.hbs | 10 +- .../GetTemplates/getTemplatesResult.hbs | 9 +- .../getTemplatesByCodeResult.hbs | 15 +- .../txnDetailResult.hbs | 14 +- .../getUserDetailsByIDResult.hbs | 13 +- .../getUserDetailsByIdAndEffDateResult.hbs | 14 +- .../getValidDocumentResult.hbs | 13 +- .../GetWeekDay/getWeekDayResult.hbs | 13 +- .../getZoneHierarchyByLangCodeResult.hbs | 22 +-- .../getZoneUserWithEffDateResult.hbs | 17 +- ...timmediateChildrenByLocationCodeResult.hbs | 9 +- .../masterdata/Holiday/holidayResult.hbs | 8 +- .../HolidaySearch/HolidaySearch.yml | 35 +--- .../HolidaySearch/holidaySearchResult.hbs | 18 +- .../IdSchema/createIdSchemaResult.hbs | 18 +- .../masterdata/Language/languageResult.hbs | 7 +- .../LocationData/locationDataResult.hbs | 13 +- .../masterdata/Machine/machineResult.hbs | 17 +- .../MachineSpecificationResult.hbs | 7 +- .../MachineType/machineTypeResult.hbs | 7 +- .../machineTypeSearchResult.hbs | 15 +- .../packetRejectionReasonCategoryResult.hbs | 7 +- .../packetRejectionReasonListResult.hbs | 7 +- .../RegCenterFilter/regCenterFilterResult.hbs | 7 +- .../RegCenterSearch/regCenterSearchResult.hbs | 55 +----- .../RegCenterType/regCenterTypeResult.hbs | 7 +- .../registrationCenterResult.hbs | 45 +---- .../registrationCenterResult.hbs | 45 +---- .../RejectionList/rejectionListResult.hbs | 7 +- .../RejectionReason/rejectionReasonResult.hbs | 7 +- .../resumePacketResult.hbs | 4 +- .../searchBlockListedWordsResult.hbs | 16 +- .../searchDocCategoriesResult.hbs | 16 +- .../searchDocumentTypeResult.hbs | 16 +- .../searchDynamicFieldResult.hbs | 37 +--- .../searchDocumentTypeResult.hbs | 16 +- .../searchLocationDataResult.hbs | 11 +- .../SearchMachine/SearchMachine.yml | 180 ++---------------- .../SearchMachine/searchMachineResult.hbs | 15 +- .../searchMachineSpecResult.hbs | 16 +- .../searchPacketResult.hbs | 23 +-- .../searchRegCenterTypeResult.hbs | 8 - .../searchTemplateDetailsResult.hbs | 18 +- .../searchUserCenterMappingResult.hbs | 19 +- .../SearchZoneUser/searchZoneUserResult.hbs | 9 +- .../masterdata/Template/templateResult.hbs | 7 +- .../templateFileFormatResult.hbs | 7 +- .../TemplateType/templateTypeResult.hbs | 7 +- .../masterdata/Title/titleResult.hbs | 7 +- .../TitleFilter/titleFilterResult.hbs | 7 +- .../TitleSearch/titleSearchResult.hbs | 14 +- .../updateblockListedWordDetailsResult.hbs | 7 +- .../updateBlockListedWordStatusResult.hbs | 7 +- .../updateDeviceSpecStatusResult.hbs | 7 +- .../updateDeviceStatusResult.hbs | 7 +- .../updateDeviceTypeResult.hbs | 7 +- .../updateteDeviceTypeStatusResult.hbs | 7 +- .../updateDocCategoryResult.hbs | 7 +- .../UpdateDocType/updateDocTypeResult.hbs | 7 +- .../updateDynamicFieldStatusResult.hbs | 7 +- .../updateHolidayStatusResult.hbs | 7 +- .../UpdateIdSchema/updateIdSchemaResult.hbs | 7 +- .../UpdateLanguage/updateLanguageResult.hbs | 7 +- .../updateLocationStatusResult.hbs | 7 +- ...dateteMachineSpecificationStatusResult.hbs | 7 +- .../updateteMachineStatusResult.hbs | 7 +- .../updateteMachineTypeStatusResult.hbs | 7 +- .../updateRegCentStatusResult.hbs | 7 +- .../updateRegCenterTypeStatusResult.hbs | 7 +- .../UpdateRegistrationCenterLang.yml | 2 +- .../updateRegistrationCenterResult.hbs | 33 +--- .../UpdateRegistrationCenterNonLanguage.yml | 2 +- .../updateRegistrationCenterResult.hbs | 47 +---- .../updateTemplateFileFormatStatusResult.hbs | 7 +- .../updateTemplateStatusResult.hbs | 7 +- .../UpdateUISpec/updateUISpecResult.hbs | 7 +- .../updateUserCenterMappingStatusResult.hbs | 7 +- .../updateWorkingDayResult.hbs | 7 +- .../updateWorkingDayStatusResult.hbs | 7 +- .../updateZoneUserStatusResult.hbs | 7 +- .../userCenterMappingResult.hbs | 8 +- .../ValidDocument/validDocumentResult.hbs | 7 +- .../validDocumentFilterResult.hbs | 7 +- .../validDocumentMapResult.hbs | 7 +- .../validDocumentSearchResult.hbs | 37 +--- .../validDocumentUnMapResult.hbs | 7 +- .../masterdata/ZoneUser/zoneUserResult.hbs | 7 +- .../src/main/resources/masterdata/error.hbs | 6 +- ...trationmachineusermappinghistoryResult.hbs | 12 +- 279 files changed, 367 insertions(+), 3293 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java index 70c96181fcc..a489494ff22 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java @@ -43,13 +43,15 @@ public static void getListOfFilesFromJarAndCopyToExternalResource(String key) { if (src != null) { URL jar = src.getLocation(); zipInputStream = new ZipInputStream(jar.openStream()); + File resourceFile = new File(MosipTestRunner.jarUrl).getParentFile(); + String resourceFileParentPath = resourceFile.getAbsolutePath() + "/MosipTestResource/"; while (true) { ZipEntry e = zipInputStream.getNextEntry(); if (e == null) break; String name = e.getName(); if (name.startsWith(key) && name.contains(".")) { - if (copyFilesFromJarToOutsideResource(name)) + if (copyFilesFromJarToOutsideResource(resourceFileParentPath, name)) LOGGER.info("Copied the file: " + name + " to external resource successfully..!"); else LOGGER.error("Fail to copy file: " + name + " to external resource"); @@ -80,14 +82,12 @@ public static void closeZipInputStream(ZipInputStream zipInputStream) { * @param path * @return */ - private static boolean copyFilesFromJarToOutsideResource(String path) { + private static boolean copyFilesFromJarToOutsideResource(String resourceFileParentPath, String resourceFileName) { try { - File resourceFile = new File(MosipTestRunner.jarUrl).getParentFile(); - File destinationFile = new File(resourceFile.getAbsolutePath() + "/MosipTestResource/" + path); - LOGGER.info("resourceFile " + MosipTestRunner.jarUrl); - LOGGER.info("destinationFile " + resourceFile.getAbsolutePath() + "/MosipTestResource/" + path); - org.apache.commons.io.FileUtils.copyInputStreamToFile(MosipTestRunner.class.getResourceAsStream("/" + path), - destinationFile); + String resourceFileAbsolutePath = resourceFileParentPath + resourceFileName; + File destinationFile = new File(resourceFileAbsolutePath); + LOGGER.info("resourceFile : " + MosipTestRunner.jarUrl + "destinationFile : " + resourceFileAbsolutePath); + org.apache.commons.io.FileUtils.copyInputStreamToFile(MosipTestRunner.class.getResourceAsStream("/" + resourceFileName), destinationFile); return true; } catch (Exception e) { LOGGER.error( @@ -95,7 +95,27 @@ private static boolean copyFilesFromJarToOutsideResource(String path) { + e.getMessage()); return false; } - } + } + + + + +// private static boolean copyFilesFromJarToOutsideResource(String path) { +// try { +// File resourceFile = new File(MosipTestRunner.jarUrl).getParentFile(); +// File destinationFile = new File(resourceFile.getAbsolutePath() + "/MosipTestResource/" + path); +// LOGGER.info("resourceFile " + MosipTestRunner.jarUrl); +// LOGGER.info("destinationFile " + resourceFile.getAbsolutePath() + "/MosipTestResource/" + path); +// org.apache.commons.io.FileUtils.copyInputStreamToFile(MosipTestRunner.class.getResourceAsStream("/" + path), +// destinationFile); +// return true; +// } catch (Exception e) { +// LOGGER.error( +// "Exception Occured in copying the resource from jar. Kindly build new jar to perform smooth test execution: " +// + e.getMessage()); +// return false; +// } +// } /** * The method to remove old generated mosip test resource diff --git a/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml b/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml index b0b7cfec4d2..86f70e4fb97 100644 --- a/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml +++ b/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml @@ -16,8 +16,6 @@ BiometricAttributes: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "$IGNORE$", - "langCode": "$IGNORE$" }' MasterData_BiometricAttributes_Invalid_empty_biometricTypeCode: @@ -64,8 +62,7 @@ BiometricAttributes: output: '{ "errors": [ { - "errorCode": "KER-APP-103", - "message": "$IGNORE$" + "errorCode": "KER-APP-103" } ] }' diff --git a/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs b/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs index 9810c5cc3ae..f7055122245 100644 --- a/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs +++ b/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs @@ -1,7 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" diff --git a/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs b/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs index e87776bc8b1..31017c0687f 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs +++ b/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml b/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml index dc8d9f3df90..923729591d2 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml @@ -59,8 +59,7 @@ UpdateBlockListedWords: output: '{ "errors": [ { - "errorCode": "KER-MSD-999", - "message": "$IGNORE$" + "errorCode": "KER-MSD-999" } ] }' @@ -105,8 +104,7 @@ UpdateBlockListedWords: output: '{ "errors": [ { - "errorCode": "KER-MSD-008", - "message": "$IGNORE$" + "errorCode": "KER-MSD-008" } ] }' diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs index 785daa1b983..e0205766751 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs @@ -1,11 +1,6 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "word":"{{word}}", "langCode":"{{langCode}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml b/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml index ee6b76c41c0..cc546522483 100644 --- a/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml +++ b/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml @@ -28,7 +28,6 @@ BulkUpload: "tableName":"gender" }' output: '{ - "transcationId": "$IGNORE$", "tableName": "gender", "operation": "update" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs b/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs index 531a869abef..4038d455ca6 100644 --- a/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs +++ b/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs @@ -1,19 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "transcationId": "$IGNORE$", "tableName": "{{tableName}}", - "operation": "{{operation}}", - "successCount": "$IGNORE$", - "category": "$IGNORE$", - "status": "$IGNORE$", - "statusDescription": "$IGNORE$", - "uploadedBy": "$IGNORE$", - "timeStamp": "$IGNORE$", - "logs": "$IGNORE$" - }, - "errors": "$IGNORE$" + "operation": "{{operation}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs index 4b99d7229ae..f7055122245 100644 --- a/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml index a77bcfe423c..a0d922905d4 100644 --- a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml +++ b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDevice.yml @@ -23,8 +23,7 @@ DecommisionDevice: output: '{ "errors": [ { - "errorCode": "KER-MSD-042", - "message": "$IGNORE$" + "errorCode": "KER-MSD-042" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs index cd3497386da..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs @@ -1,10 +1 @@ -{ -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", -"response":{ -"id":"{{id}}" -}, -"errors":"$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs b/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs index be92406a1bf..3d6bd8ac86b 100644 --- a/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml index 5cb94df4122..78d2aae5906 100644 --- a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml +++ b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml @@ -9,5 +9,4 @@ DecommissionRegCenter: "regCenterID": "$ID:CreateRegCenter_allValid_smoke_sid_id$" }' output: '{ - "id": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs index cd3497386da..7809fdbd739 100644 --- a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteBlockListedWords/deleteBlockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/DeleteBlockListedWords/deleteBlockListedWordsResult.hbs index e87776bc8b1..31017c0687f 100644 --- a/automationtests/src/main/resources/masterdata/DeleteBlockListedWords/deleteBlockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteBlockListedWords/deleteBlockListedWordsResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml index 7ee9b747bd4..5dc5578b615 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml +++ b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDevice.yml @@ -10,4 +10,5 @@ DeleteDevice: "id": "$ID:CreateDevice_All_Valid_Smoke_sid_id$" }' output: '{ + "id": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs index cd3497386da..7809fdbd739 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs index cd3497386da..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs @@ -1,10 +1 @@ -{ -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", -"response":{ -"id":"{{id}}" -}, -"errors":"$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs index 52690f1776c..26d79c493d5 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code":"{{code}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs index 52690f1776c..26d79c493d5 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code":"{{code}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDynamicField/deleteDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDynamicField/deleteDynamicFieldResult.hbs index 891a87d0d05..f8cbe60954e 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDynamicField/deleteDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDynamicField/deleteDynamicFieldResult.hbs @@ -1,10 +1,5 @@ { - "id":"$IGNORE$", - "version":"$IGNORE$", - "responsetime":"$IGNORE$", - "metadata":"$IGNORE$", "response":{ "status":"{{status}}" - }, - "errors":"$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteGenderType/DeleteGenderType.yml b/automationtests/src/main/resources/masterdata/DeleteGenderType/DeleteGenderType.yml index 57b353fc541..6342e09f39b 100644 --- a/automationtests/src/main/resources/masterdata/DeleteGenderType/DeleteGenderType.yml +++ b/automationtests/src/main/resources/masterdata/DeleteGenderType/DeleteGenderType.yml @@ -10,7 +10,6 @@ DeleteGenderType: "code": "$ID:CreateGender_Valid_Smoke_sid_code$" }' output: '{ - "code": "$IGNORE$" }' MasterData_DeleteGenderType_Invalid_code: endPoint: /v1/masterdata/gendertypes/{code} diff --git a/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs index e87776bc8b1..31017c0687f 100644 --- a/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs b/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs index 97b1a05caa6..761be98c447 100644 --- a/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs @@ -1,11 +1,6 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "locationCode": "{{locationCode}}", "holidayDate": "{{holidayDate}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs b/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs index b2d43a113d7..0af704eda69 100644 --- a/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs @@ -1,8 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs b/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs index 52690f1776c..26d79c493d5 100644 --- a/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code":"{{code}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs b/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs index be92406a1bf..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs @@ -1,10 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "id": "{{id}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs index be92406a1bf..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs @@ -1,10 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "id": "{{id}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs b/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs index cd3497386da..7809fdbd739 100644 --- a/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs index 52690f1776c..26d79c493d5 100644 --- a/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code":"{{code}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml b/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml index ded9a26aca6..6a32864431b 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml +++ b/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml @@ -10,7 +10,6 @@ DeleteTemplate: "id": "$ID:CreateTemplate_All_Valid_Smoke_sid_id$" }' output: '{ - "id": "$IGNORE$" }' MasterData_DeleteTemplate_Invalid_ID: endPoint: /v1/masterdata/templates/{id} diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs b/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs index be92406a1bf..3d6bd8ac86b 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs index 52690f1776c..26d79c493d5 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code":"{{code}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs index cd3497386da..7809fdbd739 100644 --- a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs b/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs index cd3497386da..7809fdbd739 100644 --- a/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs b/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs index 554c54f91d6..070649392ce 100644 --- a/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs @@ -1,11 +1,6 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "docCategoryCode":"{{docCategoryCode}}", "doctypecode":"{{doctypecode}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs b/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs index cd3497386da..7809fdbd739 100644 --- a/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs b/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs index 4505eb25e22..67dab45f717 100644 --- a/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs @@ -1,10 +1,5 @@ { - "id":"$IGNORE$", - "version":"$IGNORE$", - "responsetime":"$IGNORE$", - "metadata":"$IGNORE$", "response":{ - "id":"$IGNORE$", "name":"{{name}}", "serialNum":"{{serialNum}}", "deviceSpecId":"{{deviceSpecId}}", @@ -12,14 +7,6 @@ "ipAddress":"{{ipAddress}}", "langCode":"{{langCode}}", "validityDateTime":"{{validityDateTime}}", - "isActive":"{{isActive}}", - "createdBy":"$IGNORE$", - "createdDateTime":"$IGNORE$", - "updatedBy":"$IGNORE$", - "updatedDateTime":"$IGNORE$", - "isDeleted":"$IGNORE$", - "deletedDateTime":"$IGNORE$", - "regCenterId":"$IGNORE$" -}, -"errors":"$IGNORE$" + "isActive":"{{isActive}}" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml b/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml index 6a853353deb..0ec50c1b01d 100644 --- a/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml +++ b/automationtests/src/main/resources/masterdata/DeviceFilter/DeviceFilter.yml @@ -160,8 +160,7 @@ DeviceFilter: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml b/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml index 4aad1aa5950..20b7238db4c 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml @@ -232,8 +232,7 @@ DeviceSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-358", - "message": "$IGNORE$" + "errorCode": "KER-MSD-358" } ] }' diff --git a/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs index 5eaa612e1f2..b05d6f3bb88 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs @@ -1,20 +1,8 @@ { - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "id": "{{id}}", "name": "{{name}}", "serialNum": "{{serialNum}}", @@ -29,6 +17,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml index 9ddd165a77b..0805940c294 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml @@ -253,8 +253,7 @@ DeviceSpecFilter: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml index 9e8774eaf08..e4ca90be98b 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/DeviceSpecSearch.yml @@ -199,8 +199,7 @@ DeviceSpecSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' @@ -235,8 +234,7 @@ DeviceSpecSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-313", - "message": "$IGNORE$" + "errorCode": "KER-MSD-313" } ] }' @@ -271,8 +269,7 @@ DeviceSpecSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-313", - "message": "$IGNORE$" + "errorCode": "KER-MSD-313" } ] }' @@ -391,8 +388,7 @@ DeviceSpecSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-318", - "message": "$IGNORE$" + "errorCode": "KER-MSD-318" } ] }' @@ -427,8 +423,7 @@ DeviceSpecSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-318", - "message": "$IGNORE$" + "errorCode": "KER-MSD-318" } ] }' @@ -463,8 +458,7 @@ DeviceSpecSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs index b319d2ef4bb..2dd22136683 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs @@ -1,20 +1,8 @@ { - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "isActive": "{{isActive}}", "id": "{{id}}", "langCode": "{{langCode}}", @@ -29,6 +17,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs index cc257ce817b..9be53d201f0 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml index 685fcdf2f5c..4ed7f4703b7 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml +++ b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/DeviceTypeFilter.yml @@ -138,8 +138,7 @@ DeviceTypeFilter: output: '{ "errors": [ { - "errorCode": "KER-MSD-324", - "message": "$IGNORE$" + "errorCode": "KER-MSD-324" } ] }' @@ -186,8 +185,7 @@ DeviceTypeFilter: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml index 78fa690c9a6..03c1b221b26 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml @@ -211,8 +211,7 @@ DeviceTypeSearch: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs index 2a3b5ce19ea..2e609f360a2 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs @@ -1,22 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", "createdBy": "{{createdBy}}", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "code": "{{code}}", "langCode": "{{langCode}}", "name": "{{name}}", @@ -25,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs b/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs b/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs index 0736ceff345..612373a2a9a 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs @@ -1,20 +1,9 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code":"{{code}}", "langCode":"{{langCode}}", "name":"{{name}}", "description":"{{description}}", -"isActive":"{{isActive}}", -"createdBy":"$IGNORE$", -"createdDateTime":"$IGNORE$", -"updatedBy":"$IGNORE$", -"updatedDateTime":"$IGNORE$", -"isDeleted":"$IGNORE$", -"deletedDateTime":"$IGNORE$" -}, -"errors":"$IGNORE$" +"isActive":"{{isActive}}" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DynamicField/dynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/DynamicField/dynamicFieldResult.hbs index dbb37c54016..9b927f6e1c2 100644 --- a/automationtests/src/main/resources/masterdata/DynamicField/dynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/DynamicField/dynamicFieldResult.hbs @@ -1,19 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "id": "$IGNORE$", "name": "{{name}}", - "langCode": "$IGNORE$", - "dataType": "$IGNORE$", "description": "{{description}}", "fieldVal": { "code": "{{code}}", "value": "{{value}}" - }, - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdOn": "$IGNORE$" + } } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs index 11f76f039af..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs @@ -1,29 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "word": "$IGNORE$", - "langCode": "$IGNORE$", - "description": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs index 5489fd53606..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs @@ -1,13 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs index 976e226fb19..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs @@ -1,30 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/fetchAllDocumentCategoriesResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/fetchAllDocumentCategoriesResult.hbs index 50863cbaa25..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/fetchAllDocumentCategoriesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/fetchAllDocumentCategoriesResult.hbs @@ -1,30 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/fetchAllDocumentTypesResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/fetchAllDocumentTypesResult.hbs index 50863cbaa25..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/fetchAllDocumentTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/fetchAllDocumentTypesResult.hbs @@ -1,30 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllHolidays/fetchAllHolidayResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllHolidays/fetchAllHolidayResult.hbs index 3d35849aab6..3459d0decf7 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllHolidays/fetchAllHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllHolidays/fetchAllHolidayResult.hbs @@ -1,29 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", "data": [ {{#each data}} { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "isDeleted": "{{isDeleted}}", - "holidayId": $IGNORE$, - "locationCode": "$IGNORE$", - "holidayDate": "$IGNORE$", - "holidayName": "$IGNORE$", - "holidayDesc": "$IGNORE$", - "langCode": "$IGNORE$" + "isDeleted": "{{isDeleted}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllIdschema/fetchAllIdschemaResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllIdschema/fetchAllIdschemaResult.hbs index 913dad4255c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllIdschema/fetchAllIdschemaResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllIdschema/fetchAllIdschemaResult.hbs @@ -1,30 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "id": "$IGNORE$", - "idVersion": $IGNORE$, - "title": "$IGNORE$", - "description": "$IGNORE$", - "schemaJson": "$IGNORE$", - "status": "$IGNORE$", - "effectiveFrom": "$IGNORE$", - "createdBy": "$IGNORE$", - "updatedBy": "$IGNORE$", - "createdOn": "$IGNORE$", - "updatedOn": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllLocation/fetchAllLocationResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllLocation/fetchAllLocationResult.hbs index c80409b14a1..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllLocation/fetchAllLocationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllLocation/fetchAllLocationResult.hbs @@ -1,32 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentLocCode": $IGNORE$, - "langCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/fetchAllMachineSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/fetchAllMachineSpecificationResult.hbs index 8f8af03c6e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/fetchAllMachineSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/fetchAllMachineSpecificationResult.hbs @@ -1,35 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": null, - "updatedDateTime": null, - "isDeleted": $IGNORE$, - "deletedDateTime": null, - "id": "$IGNORE$", - "name": "$IGNORE$", - "brand": "$IGNORE$", - "model": "$IGNORE$", - "machineTypeCode": "$IGNORE$", - "minDriverversion": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "machineTypeName": null - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllMachineType/fetchAllMachineTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllMachineType/fetchAllMachineTypeResult.hbs index bb199740f8f..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllMachineType/fetchAllMachineTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllMachineType/fetchAllMachineTypeResult.hbs @@ -1,30 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": null, - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs index b248115e390..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs @@ -1,15 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "pageSize": "$IGNORE$", - "sort": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml b/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml index 1f0dc88b58f..f2d5c515a2a 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml @@ -10,5 +10,4 @@ FetchAllRegCenterType: }' output: '{ - "pageNo": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/fetchAllRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/fetchAllRegCenterTypeResult.hbs index 5309ae434df..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/fetchAllRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/fetchAllRegCenterTypeResult.hbs @@ -1,13 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "{{pageNo}}", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs index 5489fd53606..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs @@ -1,13 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllTitle/fetchAllTitleResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllTitle/fetchAllTitleResult.hbs index 93afc903d23..58a80bb441d 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllTitle/fetchAllTitleResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllTitle/fetchAllTitleResult.hbs @@ -1,30 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", "data": [ {{#each data}} { - "isActive": {{isActive}}, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "titleName": "$IGNORE$", - "titleDescription": "$IGNORE$", - "langCode": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml b/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml index fddf344d8fb..0978bfe8f4f 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml @@ -9,8 +9,4 @@ FetchAllUISpec: }' output: '{ - "jsonSpec": [{ - "type": "$IGNORE$", - "spec": "$IGNORE$" - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllUISpec/fetchAllUISpecResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllUISpec/fetchAllUISpecResult.hbs index 535824026fa..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllUISpec/fetchAllUISpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllUISpec/fetchAllUISpecResult.hbs @@ -1,44 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": [ - { - "id": "$IGNORE$", - "version": "$IGNORE$", - "title": "$IGNORE$", - "description": "$IGNORE$", - "identitySchemaId": "$IGNORE$", - "idSchemaVersion": "$IGNORE$", - "domain": "$IGNORE$", - "jsonSpec": [ - { - "type": "$IGNORE$", - "spec": [ - {{#each spec}} - { - "name": "$IGNORE$", - "description": "$IGNORE$", - "label": "$IGNORE$", - "fxml": "$IGNORE$", - "icon": "$IGNORE$", - "order": "$IGNORE$", - "shortcut-icon": "$IGNORE$", - "access-control": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } - ], - "status": "$IGNORE$", - "effectiveFrom": "$IGNORE$", - "createdBy": "$IGNORE$", - "updatedBy": "$IGNORE$", - "createdOn": "$IGNORE$", - "updatedOn": "$IGNORE$" - } - ], - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllUserDetails/fetchAllUserDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllUserDetails/fetchAllUserDetailsResult.hbs index 0cf94da078d..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllUserDetails/fetchAllUserDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllUserDetails/fetchAllUserDetailsResult.hbs @@ -1,25 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "mosipUserDtoList": [ - {{#each mosipUserDtoList}} - { - "userId": "$IGNORE$", - "mobile": "$IGNORE$", - "mail": "$IGNORE$", - "langCode": "$IGNORE$", - "userPassword": "$IGNORE$", - "name": "$IGNORE$ ", - "role": "$IGNORE$", - "token": "$IGNORE$", - "rid": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs index adccc9a07e4..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs @@ -1,29 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": $IGNORE$, - "totalPages": $IGNORE$, - "totalItems": $IGNORE$, - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "docTypeCode": "$IGNORE$", - "docCategoryCode": "$IGNORE$", - "langCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml b/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml index 733a3229502..53e4e3f6c29 100644 --- a/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml +++ b/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml @@ -8,14 +8,4 @@ FetchAppConfig: input: '{ }' output: '{ - "primaryLangCode": "$IGNORE$", - "secondaryLangCode": "$IGNORE$", - "supportedLanguages": "$IGNORE$", - "leftToRightOrientation": "$IGNORE$", - "countryCode": "$IGNORE$", - "locationHierarchyLevel": "$IGNORE$", - "rightToLeftOrientation": "$IGNORE$", - "version": "$IGNORE$", - "optionalLanguages": "$IGNORE$", - "mandatoryLanguages": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs b/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs index 3bca224595d..48181c1b195 100644 --- a/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs @@ -1,19 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "primaryLangCode": "$IGNORE$", - "secondaryLangCode": "$IGNORE$", - "supportedLanguages": "$IGNORE$", - "leftToRightOrientation": "$IGNORE$", - "countryCode": "$IGNORE$", - "locationHierarchyLevel": "$IGNORE$", - "rightToLeftOrientation": "$IGNORE$", - "version": "$IGNORE$", - "optionalLanguages": "$IGNORE$", "mandatoryLanguages": "{{mandatoryLanguages}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs index 06c50374324..882d2764954 100644 --- a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs @@ -1,20 +1,12 @@ { - "id":"$IGNORE$", - "version":"$IGNORE$", - "responsetime":"$IGNORE$", - "metadata":"$IGNORE$", "response":{ "blocklistedwords":[ {{#each blocklistedwords}} { - "word":"$IGNORE$", - "langCode":"{{langCode}}", - "description":"$IGNORE$", - "isActive":"$IGNORE$" + "langCode":"{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors":"$IGNORE$" + } } diff --git a/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs b/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs index e5a05ac0e76..da07441a7e8 100644 --- a/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs @@ -1,18 +1,14 @@ { -"responsetime": "$IGNORE$", "response": { "devices": [ {{#each devices}} { - "id": "$IGNORE$", "name": "{{name}}", "serialNum": "{{serialNum}}", "deviceSpecId": "{{deviceSpecId}}", "macAddress": "{{macAddress}}", - "ipAddress": "$IGNORE$", "langCode": "{{langCode}}", "isActive": {{isActive}}, - "validityDateTime": "$IGNORE$", "deviceTypeCode": "{{deviceTypeCode}}", "zoneCode": "{{zoneCode}}", "regCenterId": "{{regCenterId}}" diff --git a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs index 4f8fae21c13..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs @@ -1,25 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "devicespecifications": [ - {{#each devicespecifications}} - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "brand": "$IGNORE$", - "model": "$IGNORE$", - "deviceTypeCode": "$IGNORE$", - "minDriverversion": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "{{langCode}}", - "isActive": {{isActive}} - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs index 394dc56d52d..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs index f9bfab29266..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs @@ -1,17 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": [ - {{#each response}} - { - "name": "$IGNORE$", - "description": "$IGNORE$", - "isActive": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs index b605953e7d2..ad20b3b7310 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs @@ -1,21 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "documentcategories": [ {{#each documentcategories}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs index 9ff4dd9de63..cac1d9e7014 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs @@ -1,21 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "documenttypes": [ {{#each documenttypes}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs index 9ff4dd9de63..cac1d9e7014 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs @@ -1,21 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "documenttypes": [ {{#each documenttypes}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs index 5b9464e9bb8..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs @@ -1,40 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "totalPages": "$IGNORE$", - "totalItems": "$IGNORE$", - "data": [ - {{#each data}} - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "langCode": "$IGNORE$", - "dataType": "$IGNORE$", - "description": "$IGNORE$", - "fieldVal": [ - {{#each fieldVal}} - { - "code": "$IGNORE$", - "value": "$IGNORE$", - "langCode": "$IGNORE$", - "active": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "updatedBy": "$IGNORE$", - "createdOn": "$IGNORE$", - "updatedOn": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml b/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml index 14696e22d0f..f65c18be3dc 100644 --- a/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml +++ b/automationtests/src/main/resources/masterdata/FetchGenderType/FetchGenderType.yml @@ -25,7 +25,6 @@ FetchGenderType: "gendername":"Male" }' output: '{ - "status": "$IGNORE$" }' Masterdata_FetchGenderType_Validate_gender_name_invalid: endPoint: /v1/masterdata/gendertypes/validate/{gendername} diff --git a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs index d2f85ecb48b..04f89a999be 100644 --- a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs @@ -1,20 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "genderType": [ {{#each genderType}} { - "code": "$IGNORE$", - "genderName": "$IGNORE$", "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs b/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs index ee73b87ab2e..d8cd9a79807 100644 --- a/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs @@ -1,22 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "holidays": [ {{#each holidays}} { - "locationCode": "$IGNORE$", - "holidayDate": "$IGNORE$", - "holidayName": "$IGNORE$", - "holidayDesc": "$IGNORE$", "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml b/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml index 4974577d00c..e06ac1c4508 100644 --- a/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml +++ b/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml @@ -9,5 +9,4 @@ FetchIdSchema: }' output: '{ - "response": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/masterdata/FetchIdSchema/fetchIdSchemaResult.hbs b/automationtests/src/main/resources/masterdata/FetchIdSchema/fetchIdSchemaResult.hbs index 21504a1c3f2..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchIdSchema/fetchIdSchemaResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchIdSchema/fetchIdSchemaResult.hbs @@ -1,23 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "schema": "$IGNORE$", - "settings": "$IGNORE$", - "updatedBy": "$IGNORE$", - "idVersion": $IGNORE$, - "description": "$IGNORE$", - "updatedOn": "$IGNORE$", - "title": "$IGNORE$", - "createdOn": "$IGNORE$", - "screens": "$IGNORE$", - "createdBy": "$IGNORE$", - "schemaJson": "$IGNORE$", - "id": "$IGNORE$", - "effectiveFrom": "$IGNORE$", - "status": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs index 324d8aeeb00..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs @@ -1,22 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "isActive": true, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs index d391846c02e..36beeea7f4e 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs @@ -1,23 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "locations": [ {{#each locations}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "{langCode}", - "isActive": $IGNORE$ + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationResult.hbs index 873a3ce61cc..647d761c5a9 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationResult.hbs @@ -1,19 +1,11 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "locations": [ {{#each locations}} { - "locationHierarchylevel": $IGNORE$, - "locationHierarchyName": "$IGNORE$", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs index 88316863e72..cde6820600d 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs @@ -1,17 +1,13 @@ { -"responsetime": "$IGNORE$", "response": { "locationHierarchyLevels": [ {{#each locationHierarchyLevels}} { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs b/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs index 39e0b1cebbe..835ef4f43b4 100644 --- a/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs @@ -1,39 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "pageNo": "$IGNORE$", - "pageSize": "$IGNORE$", - "sort": { - "unsorted": "$IGNORE$", - "sorted": "$IGNORE$" - }, - "totalItems": "$IGNORE$", - "totalPages": "$IGNORE$", "data": [ {{#each data}} { - "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "regCentId": "$IGNORE$", - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "machineSpecId": "$IGNORE$", - "macAddress": "$IGNORE$", - "ipAddress": "$IGNORE$", - "langCode": "$IGNORE$" + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml b/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml index 8fb142a07a3..900aea9168d 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml @@ -11,7 +11,6 @@ FetchMissingDynamicField: "fieldName": null }' output: '{ - "response": "$IGNORE$" }' MasterData_FetchMissingDynamicField_Allvalid_smoke: endPoint: /v1/masterdata/dynamicfields/missingids/{langcode}?fieldName={fieldName} @@ -25,5 +24,4 @@ FetchMissingDynamicField: "fieldName": "description" }' output: '{ - "response": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/fetchMissingDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/fetchMissingDynamicFieldResult.hbs index 6f535a41eda..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/fetchMissingDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/fetchMissingDynamicFieldResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml b/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml index b3c81803e67..14d55907500 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml @@ -9,5 +9,4 @@ FetchMissingLocation: "langcode": "eng" }' output: '{ - "response": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingLocation/fetchMissingLocationResult.hbs b/automationtests/src/main/resources/masterdata/FetchMissingLocation/fetchMissingLocationResult.hbs index 6f535a41eda..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingLocation/fetchMissingLocationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMissingLocation/fetchMissingLocationResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml index 2ca75329f00..a3867374652 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml @@ -10,5 +10,4 @@ FetchMissingRegCenterDetails: "langcode": "eng" }' output: '{ - "response": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/fetchMissingRegCenterDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/fetchMissingRegCenterDetailsResult.hbs index 6f535a41eda..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/fetchMissingRegCenterDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/fetchMissingRegCenterDetailsResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/fetchMissingRegCenterTypeDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/fetchMissingRegCenterTypeDetailsResult.hbs index 6f535a41eda..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/fetchMissingRegCenterTypeDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/fetchMissingRegCenterTypeDetailsResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml index 258352a9a63..56e3db5e5fc 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml @@ -11,7 +11,6 @@ FetchMissingTemplates: "fieldName": "$REMOVE$" }' output: '{ - "response": "$IGNORE$" }' MasterData_FetchMissingTemplates_Allvalid_smoke: endPoint: /v1/masterdata/templates/missingids/{langcode}?fieldName={fieldName} @@ -25,5 +24,4 @@ FetchMissingTemplates: "fieldName": "description" }' output: '{ - "response": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs index 6f535a41eda..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml b/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml index 887861a32b2..f0fc472eed7 100644 --- a/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml +++ b/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml @@ -10,11 +10,7 @@ FetchModule: }' output: '{ "modules": [{ - "id": "$IGNORE$", - "name": "$IGNORE$", - "langCode": "eng", - "description": "$IGNORE$", - "isActive": "$IGNORE$" + "langCode": "eng" }] }' MasterData_FetchModule_Invalid_smoke_with_Invalid_langcode: diff --git a/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs b/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs index f87d7480169..b100cd1694f 100644 --- a/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs @@ -1,21 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "modules": [ {{#each modules}} { - "id": "$IGNORE$", - "name": "$IGNORE$", - "langCode": "{{langCode}}", - "description": "$IGNORE$", - "isActive": $IGNORE$ + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml index 7f89e33735e..8a91f5bf56b 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml @@ -22,9 +22,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_coordinate_specific_allValid_smoke: endPoint: /v1/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} @@ -49,9 +46,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_coordinate_specific_invalid_latitude: @@ -133,9 +127,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_By_LocationCode_invalid_locationcode: endPoint: /v1/masterdata/getlocspecificregistrationcenters/{langcode}/{locationcode} @@ -188,7 +179,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ - "langCode": "$IGNORE$" }' MasterData_FetchRegCent_Holidays_invalid_registrationcenterid: @@ -242,9 +232,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_By_HierarchyLevel_Text_langCode_allValid_smoke: @@ -353,9 +340,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_validateTimestamp_allValid_smoke: endPoint: /v1/masterdata/registrationcenters/validate/{id}/{langcode}/{timestamp} @@ -433,8 +417,7 @@ FetchRegCent: output: '{ "errors": [ { - "errorCode": "KER-MSD-033", - "message": "$IGNORE$" + "errorCode": "KER-MSD-033" } ] }' @@ -461,9 +444,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_by_langCode_zoneCode_InValid_zonecode: @@ -604,9 +584,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_By_zoneCode_invalid_invalid_zonecode: endPoint: /v1/masterdata/getzonespecificregistrationcenters/{langcode}/{zonecode} diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentResult.hbs index 2954cf4b0c5..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentResult.hbs @@ -1,36 +1 @@ -{ -"responsetime": "$IGNORE$", -"response": { - "registrationCenters": [ - {{#each registrationCenters}} - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentWithPaginationResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentWithPaginationResult.hbs index e6266e23a6b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentWithPaginationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchAllRegCentWithPaginationResult.hbs @@ -1,52 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "pageSize": "$IGNORE$", - "sort": "$IGNORE$", - "totalItems": "$IGNORE$", - "totalPages": "$IGNORE$", - "data": [ - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": $IGNORE$, - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs index 659672b5733..47bea2996bb 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs @@ -1,46 +1,8 @@ { -"responsetime": "$IGNORE$", "response": { "registrationCenter": { - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "{{langCode}}", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" - }, - "holidays": [ - {{#each holidays}} - { - "locationCode": "$IGNORE$", - "holidayDate": "$IGNORE$", - "holidayName": "$IGNORE$", - "holidayDesc": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "holidayId": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" + "langCode": "{{langCode}}" + } + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs index 829bb500d20..9726e07e221 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs @@ -1,36 +1,12 @@ { -"responsetime": "$IGNORE$", "response": { "registrationCenters": [ {{#each registrationCenters}} { - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "{{langCode}}", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/FetchRegCentDeviceHistory.yml b/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/FetchRegCentDeviceHistory.yml index ff3ecf9dbed..875f98cf5a1 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/FetchRegCentDeviceHistory.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/FetchRegCentDeviceHistory.yml @@ -73,8 +73,7 @@ FetchRegCentDeviceHistory: output: '{ "errors": [ { - "errorCode": "KER-MSD-033", - "message": "$IGNORE$" + "errorCode": "KER-MSD-033" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/fetchRegCentDeviceHistoryResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/fetchRegCentDeviceHistoryResult.hbs index 365d5d79045..2f2d48fd59b 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/fetchRegCentDeviceHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCentDeviceHistory/fetchRegCentDeviceHistoryResult.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "registrationCenterDeviceHistoryDetails": { "regCenterId": "{{regCenterId}}", - "deviceId": "{{deviceId}}", - "isActive": $IGNORE$, - "langCode": "$IGNORE$", - "effectivetimes": "$IGNORE$" + "deviceId": "{{deviceId}}" } -}, - "errors": "$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs index b6855eb57a4..f9a765490c9 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs @@ -1,33 +1,10 @@ { -"responsetime": "$IGNORE$", "response": { "registrationCentersHistory": [ {{#each registrationCentersHistory}} { - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", "langCode": "{{langCode}}", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "{{isActive}}", - "effectivetimes": "$IGNORE$", - "zoneCode": "$IGNORE$" + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml index 8938aab584f..bbbb83ce036 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml +++ b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml @@ -39,7 +39,6 @@ FetchTemplate: }' output: '{ "templates": [{ - "langCode": "$IGNORE$", "isActive": true }] }' diff --git a/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs b/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs index 9784f8c33f6..5ace9e990f8 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs @@ -1,27 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templates": [ {{#each templates}} { - "id": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "fileFormatCode": "$IGNORE$", - "model": "$IGNORE$", - "fileText": "$IGNORE$", - "moduleId": "$IGNORE$", - "moduleName": "$IGNORE$", - "templateTypeCode": "$IGNORE$", "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs index 6bac5f834cd..1a8542e8861 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs @@ -1,20 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templateTypes": [ {{#each templateTypes}} { - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "description": "$IGNORE$", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs b/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs index 56b0ade8d4b..5315a7502ce 100644 --- a/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs @@ -1,21 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "titleList": [ {{#each titleList}} { - "code": "$IGNORE$", - "titleName": "$IGNORE$", - "titleDescription": "$IGNORE$", "isActive": {{isActive}}, "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml b/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml index 1d46321483a..e0f4c5b8fb6 100644 --- a/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml @@ -9,8 +9,4 @@ FetchUISpec: "domain": "registration-client" }' output: '{ - "jsonSpec": [{ - "type": "$IGNORE$", - "spec": "$IGNORE$" - }] }' diff --git a/automationtests/src/main/resources/masterdata/FetchUISpec/fetchUISpecResult.hbs b/automationtests/src/main/resources/masterdata/FetchUISpec/fetchUISpecResult.hbs index 535824026fa..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchUISpec/fetchUISpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchUISpec/fetchUISpecResult.hbs @@ -1,44 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": [ - { - "id": "$IGNORE$", - "version": "$IGNORE$", - "title": "$IGNORE$", - "description": "$IGNORE$", - "identitySchemaId": "$IGNORE$", - "idSchemaVersion": "$IGNORE$", - "domain": "$IGNORE$", - "jsonSpec": [ - { - "type": "$IGNORE$", - "spec": [ - {{#each spec}} - { - "name": "$IGNORE$", - "description": "$IGNORE$", - "label": "$IGNORE$", - "fxml": "$IGNORE$", - "icon": "$IGNORE$", - "order": "$IGNORE$", - "shortcut-icon": "$IGNORE$", - "access-control": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } - ], - "status": "$IGNORE$", - "effectiveFrom": "$IGNORE$", - "createdBy": "$IGNORE$", - "updatedBy": "$IGNORE$", - "createdOn": "$IGNORE$", - "updatedOn": "$IGNORE$" - } - ], - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchValidDocuments/fetchValidDocumentsResult.hbs b/automationtests/src/main/resources/masterdata/FetchValidDocuments/fetchValidDocumentsResult.hbs index a05245b6e6b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchValidDocuments/fetchValidDocumentsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchValidDocuments/fetchValidDocumentsResult.hbs @@ -1,33 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "documentcategories": [ - {{#each documentcategories}} - { - "code": "{{code}}", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "documenttypes": [ - {{#each documenttypes}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } -{{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/fetchValidDocumentsByDocCategoryCodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/fetchValidDocumentsByDocCategoryCodeResult.hbs index a781c348e5b..63d2ea0d008 100644 --- a/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/fetchValidDocumentsByDocCategoryCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/fetchValidDocumentsByDocCategoryCodeResult.hbs @@ -1,19 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": [ {{#each response}} { - "docTypeCode": "$IGNORE$", - "docCategoryCode": "{{docCategoryCode}}", - "docTypeName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" + "docCategoryCode": "{{docCategoryCode}}" } {{#unless @last}},{{/unless}} {{/each}} - ], - "errors": "$IGNORE$" + ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/invalidValidDocumentsByDocCategoryCodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/invalidValidDocumentsByDocCategoryCodeResult.hbs index 36105e297bb..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/invalidValidDocumentsByDocCategoryCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/invalidValidDocumentsByDocCategoryCodeResult.hbs @@ -1,4 +1 @@ -{ - "responsetime": "$IGNORE$", - "response": [] -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs b/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs index 0257792844a..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs @@ -1,20 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "workingdays": [ - {{#each workingdays}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "order": "$IGNORE$", - "languageCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterBlockListedWords/FilterBlockListedWords.yml b/automationtests/src/main/resources/masterdata/FilterBlockListedWords/FilterBlockListedWords.yml index d060143c91c..f329c2b0ad7 100644 --- a/automationtests/src/main/resources/masterdata/FilterBlockListedWords/FilterBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/FilterBlockListedWords/FilterBlockListedWords.yml @@ -114,8 +114,7 @@ FilterBlockListedWords: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml b/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml index 436cfd79cc9..b138af6801d 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml +++ b/automationtests/src/main/resources/masterdata/FilterDocCategory/FilterDocCategory.yml @@ -106,8 +106,7 @@ FilterDocCategory: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDynamicField/FilterDynamicField.yml b/automationtests/src/main/resources/masterdata/FilterDynamicField/FilterDynamicField.yml index e493572527e..26a11c4c898 100644 --- a/automationtests/src/main/resources/masterdata/FilterDynamicField/FilterDynamicField.yml +++ b/automationtests/src/main/resources/masterdata/FilterDynamicField/FilterDynamicField.yml @@ -119,8 +119,7 @@ FilterDynamicField: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml b/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml index 81c3239e37e..f2a0d808aef 100644 --- a/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml +++ b/automationtests/src/main/resources/masterdata/FilterHolidays/FilterHolidays.yml @@ -37,8 +37,7 @@ FilterHolidays: output: '{ "errors": [ { - "errorCode": "KER-MSD-324", - "message": "$IGNORE$" + "errorCode": "KER-MSD-324" } ] }' @@ -157,8 +156,7 @@ FilterHolidays: output: '{ "errors": [ { - "errorCode": "KER-MSD-999", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' @@ -192,7 +190,7 @@ FilterHolidays: templateFields: ["text"] restMethod: post inputTemplate: masterdata/FilterHolidays/filterHolidays - outputTemplate: masterdata/FilterHolidays/filterHolidaysResult + outputTemplate: masterdata/error input: '{ "filters": [{ "columnName": "holidayName", @@ -205,8 +203,7 @@ FilterHolidays: output: '{ "errors": [ { - "errorCode": "KER-MSD-999", - "message": "$IGNORE$" + "errorCode": "KER-MSD-999" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs b/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs b/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml b/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml index 376dd826822..4b0cee5eeda 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/FilterMachineSpec/FilterMachineSpec.yml @@ -253,8 +253,7 @@ FilterMachineSpec: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' @@ -301,8 +300,7 @@ FilterMachineSpec: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs index e57af980266..1f8746bee84 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml b/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml index 0672196647c..9a5dd529856 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml +++ b/automationtests/src/main/resources/masterdata/FilterMachineType/FilterMachineType.yml @@ -129,8 +129,7 @@ FilterMachineType: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs b/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs index e57af980266..1f8746bee84 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachines/FilterMachines.yml b/automationtests/src/main/resources/masterdata/FilterMachines/FilterMachines.yml index 9809287cb48..110e66e6b64 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachines/FilterMachines.yml +++ b/automationtests/src/main/resources/masterdata/FilterMachines/FilterMachines.yml @@ -114,8 +114,7 @@ FilterMachines: output: '{ "errors": [ { - "errorCode": "KER-MSD-317", - "message": "$IGNORE$" + "errorCode": "KER-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs b/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs index e57af980266..1f8746bee84 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs index 15c1554caa7..74f9a1f698f 100644 --- a/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs index e0381953f1d..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs index 224a3490f5a..c90acceb573 100644 --- a/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs b/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs +++ b/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs b/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs index e0381953f1d..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs b/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs index 712f5d3bdf8..17d99e38a5c 100644 --- a/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs +++ b/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs @@ -1,17 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", "code": "{{code}}", "genderName": "{{genderName}}", "langCode": "{{langCode}}" diff --git a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs index 210d28a8d9c..8a9302f107f 100644 --- a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs @@ -1,26 +1,11 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "pageNo": 0, - "totalPages": $IGNORE$, - "totalItems": $IGNORE$, "data": [ { - "transcationId": "$IGNORE$", "entityName": "{{entityName}}", "operation": "{{operation}}", - "count": $IGNORE$, - "category": "{{category}}", - "status": "$IGNORE$", - "statusDescription": "$IGNORE$", - "uploadedBy": "$IGNORE$", - "timeStamp": "$IGNORE$", - "logs": "$IGNORE$" + "category": "{{category}}" } ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs index c84dd462a30..a6e8c24e747 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs @@ -1,12 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "applicantType": { "applicantTypeCode": "{{applicantTypeCode}}" } - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml index 2ff960fcf2b..707ac04e4d2 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml +++ b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml @@ -9,5 +9,7 @@ GetCredentialTypes: input: '{ }' output: '{ - + "primaryLangCode": "$IGNORE$", + "secondaryLangCode": "$IGNORE$", + "version": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs index 684802f0781..7d6099ea3b0 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs @@ -1,12 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "primaryLangCode": "{{primaryLangCode}}", "secondaryLangCode": "{{secondaryLangCode}}", "version": "{{version}}" - }, - "errors": $IGNORE$ + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs index 7e1abe85d36..f4df188b204 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs @@ -1,18 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "applicationtypes": [ { "code": "{{code}}", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "{{langCode}}", - "isActive": "$IGNORE$" + "langCode": "{{langCode}}" } ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs index fd9b4315b93..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs @@ -1,21 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "applicationtypes": [ - {{#each applicationtypes}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs index 8936db69712..1193b3b30cf 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs @@ -1,21 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "applicationtypes": [ {{#each applicationtypes}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "{{langCode}}", - "isActive": "$IGNORE$" + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs index d1e1999d620..d07033101a9 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs @@ -1,23 +1,14 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "biometricattributes": [ {{#each biometricattributes}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", "biometricTypeCode": "{{biometricTypeCode}}", - "langCode": "{{langCode}}", - "isActive": $IGNORE$ + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs index 2110a214f2e..fa0b3081a3b 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs @@ -1,18 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "biometrictypes": [ { "code": "{{code}}", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "{{langCode}}", - "isActive": "$IGNORE$" + "langCode": "{{langCode}}" } ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs index 1ac3563a1ea..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs @@ -1,21 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "biometrictypes": [ - {{#each biometrictypes}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs index 66564377c5d..66b31622eb2 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs @@ -1,21 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "biometrictypes": [ {{#each biometrictypes}} { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "{{langCode}}", - "isActive": "$IGNORE$" + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryNotFoundError.hbs b/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryNotFoundError.hbs index f4d082ebd73..a23776a3ee6 100644 --- a/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryNotFoundError.hbs +++ b/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryNotFoundError.hbs @@ -3,5 +3,4 @@ "status": 404, "error": "Not Found", "message": "No message available", - "path": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs b/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs index 11b89168dc3..ca289e5b43b 100644 --- a/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs @@ -1,26 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "deviceHistoryDetails": [ {{#each deviceHistoryDetails}} { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "ipAddress": "$IGNORE$", - "macAddress": "$IGNORE$", - "deviceSpecId": "$IGNORE$", "langCode": "{{langCode}}", - "isActive": {{isActive}}, - "effectDateTime": "$IGNORE$", - "validityDateTime": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } diff --git a/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs index fb00f984501..6361e47cf28 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "documentcategories": [ @@ -17,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs index fb00f984501..6361e47cf28 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "documentcategories": [ @@ -17,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs b/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs index 57b8df8ae75..a6ccd71b634 100644 --- a/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs @@ -1,25 +1,15 @@ { - "id":"$IGNORE$", - "version":"$IGNORE$", - "responsetime":"$IGNORE$", - "metadata":"$IGNORE$", "response":{ - "appTypeCode":"$IGNORE$", "langCode":"{{langCode}}", "isActive":{{isActive}}, "documentCategories":[ {{#each documentCategories}} { - "code":"$IGNORE$", - "name":"$IGNORE$", - "description":"$IGNORE$", "langCode":"{{langCode}}", - "isActive":{{isActive}}, - "documentTypes":"$IGNORE$" + "isActive":{{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors":"$IGNORE$" + } } diff --git a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs index 2daaaf4a3b1..e3b48b3292e 100644 --- a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "documenttypes": [ @@ -17,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs index 9fc9b5e6b97..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs @@ -1,27 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "exceptionalHolidayList": [ - - {{#each exceptionalHolidayList}} - { - "holidayDate": "$IGNORE$", - "holidayDay": "$IGNORE$", - "holidayMonth": "$IGNORE$", - "holidayYear": "$IGNORE$", - "holidayName": "$IGNORE$", - "holidayReason": "$IGNORE$", - "registrationCenterID": "$IGNORE$", - "isDeleted": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": $IGNORE$ - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs b/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs index f0230fac330..0a7b0e86362 100644 --- a/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs @@ -1,12 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}", - "fieldValue": "{{fieldValue}}", - "langCode": "$IGNORE$" - }, - "errors": "$IGNORE$" + "fieldValue": "{{fieldValue}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs index 125b2e42cf9..5343ad31236 100644 --- a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "idtypes": [ @@ -17,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetIndividualType/getIndividualTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetIndividualType/getIndividualTypeResult.hbs index 8abd71d1661..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetIndividualType/getIndividualTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetIndividualType/getIndividualTypeResult.hbs @@ -1,26 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "data": [ - {{#each data}} - { - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$", - "isActive": $IGNORE$ - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs b/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs index dfb7b89deba..a24e1124fa9 100644 --- a/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "languages": [ @@ -12,11 +8,10 @@ "name": "{{name}}", "family": "{{family}}", "nativeName": "{{nativeName}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs index 69245104539..f4a42f02345 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs @@ -1,23 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "{{langCode}}", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentZoneCode": "$IGNORE$", - "hierarchyPath": "$IGNORE$" + "langCode": "{{langCode}}" }, "errors": $IGNORE$ } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs index 69245104539..a9c07c57aa6 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs @@ -1,23 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "{{langCode}}", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentZoneCode": "$IGNORE$", - "hierarchyPath": "$IGNORE$" - }, - "errors": $IGNORE$ + "langCode": "{{langCode}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs index a8b06b7466b..1f91105fe9c 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "locations": [ @@ -14,11 +10,10 @@ "hierarchyName": "{{hierarchyName}}", "parentLocCode": "{{parentLocCode}}", "langCode": "{{langCode}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs index c5e0dd4f7ff..996b9470269 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "locationHierarchyLevels": [ @@ -11,11 +7,10 @@ "hierarchyLevel": "{{hierarchyLevel}}", "hierarchyLevelName": "{{hierarchyLevelName}}", "langCode": "{{langCode}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs b/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs index be04da35a6f..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs @@ -1,33 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": $IGNORE$, - "totalPages": $IGNORE$, - "totalItems": $IGNORE$, - "data": [ - - {{#each data}} - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs b/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs index 4e12bcdec4c..87e3633d417 100644 --- a/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "machineHistoryDetails": [ @@ -22,6 +18,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs b/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs index 7fce7f49b14..3ad56e71f73 100644 --- a/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "machines": [ @@ -25,6 +21,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/getMappedMachinesByRegCentIDResult.hbs b/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/getMappedMachinesByRegCentIDResult.hbs index bd36eb36121..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/getMappedMachinesByRegCentIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/getMappedMachinesByRegCentIDResult.hbs @@ -1,29 +1 @@ -{ - "responsetime": "$IGNORE$", - "response": { - "pageNo": $IGNORE$, - "pageSize": $IGNORE$, - "sort": { - "unsorted": $IGNORE$, - "sorted": $IGNORE$ - }, - "totalItems": $IGNORE$, - "totalPages": $IGNORE$, - "data": [ - { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "regCentId": "$IGNORE$", - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "macAddress": "$IGNORE$", - "ipAddress": "$IGNORE$", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$" - } - ] - } -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs index 58154a9d79a..5ec6a03037a 100644 --- a/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs @@ -1,14 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": [ { - "id": "{{id}}", - "fieldValue": $IGNORE$, - "langCode": "$IGNORE$" + "id": "{{id}}" } - ], - "errors": "$IGNORE$" + ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs index 57adfa4bf80..51f1bd7feed 100644 --- a/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs @@ -1,17 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": [ {{#each response}} { - "id": "{{id}}", - "fieldValue": "$IGNORE$", - "langCode": "$IGNORE$" + "id": "{{id}}" } {{#unless @last}},{{/unless}} {{/each}} - ], - "errors": "$IGNORE$" + ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs index d9106365621..effd18e6eaf 100644 --- a/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "modules": [ @@ -10,13 +6,11 @@ { "id": "{{id}}", "name": "{{name}}", - "langCode": "$IGNORE$", "description": "{{description}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs index d9106365621..0eba6a751e7 100644 --- a/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "modules": [ @@ -10,13 +6,11 @@ { "id": "{{id}}", "name": "{{name}}", - "langCode": "$IGNORE$", "description": "{{description}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs b/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs index 4fe46f84ed5..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs @@ -1,34 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "reasonCategories": [ - {{#each reasonCategories}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "reasonList": [ - {{#each reasonList}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "rsnCatCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs b/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs index 43c838226f5..e3c0ec2cab4 100644 --- a/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "eng": [ {{#each eng}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs index 69245104539..a9c07c57aa6 100644 --- a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs @@ -1,23 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "{{langCode}}", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentZoneCode": "$IGNORE$", - "hierarchyPath": "$IGNORE$" - }, - "errors": $IGNORE$ + "langCode": "{{langCode}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs index 47164eb60b6..9efd23c4070 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs @@ -1,20 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templateFileFormats": [ {{#each templateFileFormats}} { "code": "{{code}}", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs index 6bac5f834cd..1a8542e8861 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs @@ -1,20 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templateTypes": [ {{#each templateTypes}} { - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "description": "$IGNORE$", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs index 6bac5f834cd..1a8542e8861 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs @@ -1,20 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templateTypes": [ {{#each templateTypes}} { - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "description": "$IGNORE$", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs index 634308ac1f3..46f1d85ef10 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templates": [ {{#each templates}} @@ -17,11 +13,10 @@ "moduleName": "ID Authentication", "templateTypeCode": "{{templateTypeCode}}", "langCode": "{{langCode}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs index 7036ffb8165..7ffb9c6964d 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs @@ -1,23 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "templates": [ {{#each templates}} { - "id": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "fileFormatCode": "$IGNORE$", - "model": "$IGNORE$", - "fileText": "$IGNORE$", - "moduleId": "$IGNORE$", - "moduleName": "$IGNORE$", "templateTypeCode": "{{templateTypeCode}}", - "langCode": "$IGNORE$", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/GetTxnDetailBulkUpload/txnDetailResult.hbs b/automationtests/src/main/resources/masterdata/GetTxnDetailBulkUpload/txnDetailResult.hbs index 384e4d7a5f1..557737615e2 100644 --- a/automationtests/src/main/resources/masterdata/GetTxnDetailBulkUpload/txnDetailResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTxnDetailBulkUpload/txnDetailResult.hbs @@ -1,19 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "transcationId": "$IGNORE$", "entityName": "{{entityName}}", "operation": "{{operation}}", - "count": $IGNORE$, "category": "{{category}}", - "status": "$IGNORE$", - "statusDescription": "$IGNORE$", - "uploadedBy": "$IGNORE$", - "timeStamp": "$IGNORE$", - "logs": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs index f1c38ebe483..78405243db3 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs @@ -1,16 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}", - "name": "$IGNORE$", - "statusCode": "$IGNORE$", - "regCenterId": "{{regCenterId}}", - "isActive": $IGNORE$, - "zoneCode": "$IGNORE$" - }, - "errors": $IGNORE$ + "regCenterId": "{{regCenterId}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs index 6b653a3c56b..5fb13c4cc7f 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs @@ -1,18 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "userResponseDto": [{ "id": "{{id}}", - "langCode": "{{langCode}}", - "name": "$IGNORE$", - "statusCode": "$IGNORE$", - "regCenterId": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" + "langCode": "{{langCode}}" }] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs b/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs index 983c7719b80..792b4193c24 100644 --- a/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs @@ -1,14 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": [{ - "docTypeCode": "$IGNORE$", - "docCategoryCode": "$IGNORE$", - "docTypeName": "$IGNORE$", - "langCode": "eng", - "isActive": $IGNORE$ - }], - "errors": $IGNORE$ + "langCode": "eng" + }] } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs b/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs index 6fb82f996e3..3d9127b2545 100644 --- a/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs @@ -1,21 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "weekdays": [ {{#each weekdays}} { - "name": "$IGNORE$", - "dayCode": "$IGNORE$", - "languageCode": "{{languageCode}}", - "working": $IGNORE$, - "globalWorking": $IGNORE$ + "languageCode": "{{languageCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": $IGNORE$ + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs index 69245104539..a9c07c57aa6 100644 --- a/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs @@ -1,23 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "isActive": $IGNORE$, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "{{langCode}}", - "name": "$IGNORE$", - "hierarchyLevel": $IGNORE$, - "hierarchyName": "$IGNORE$", - "parentZoneCode": "$IGNORE$", - "hierarchyPath": "$IGNORE$" - }, - "errors": $IGNORE$ + "langCode": "{{langCode}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs b/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs index bb113bb028c..647434a2836 100644 --- a/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs @@ -1,25 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "userResponseDto": [ {{#each userResponseDto}} { - "isActive": {{isActive}}, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, - "deletedDateTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "userId": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs index a8b06b7466b..1f91105fe9c 100644 --- a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "locations": [ @@ -14,11 +10,10 @@ "hierarchyName": "{{hierarchyName}}", "parentLocCode": "{{parentLocCode}}", "langCode": "{{langCode}}", - "isActive": {{isActive}} + "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs b/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs index d6fe6160506..a6b225cac76 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs @@ -1,14 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "holidayId": "$IGNORE$", "locationCode": "{{locationCode}}", "holidayDate": "{{holidayDate}}", "holidayName": "{{holidayName}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml b/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml index 04a1998e146..c5600b5842f 100644 --- a/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml +++ b/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml @@ -2,6 +2,7 @@ HolidaySearch: MasterData_HolidaySearch_equals_holidayName_eng_pos: endPoint: /v1/masterdata/holidays/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/HolidaySearch/holidaySearch @@ -28,16 +29,11 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "holidayId": "$IGNORE$", - "name": "$IGNORE$", - "holidayDate": "2020-08-15", - "holidayName": "AutoTest user Eng", - "holidayDesc": "$IGNORE$", - "langCode": "eng" }' MasterData_HolidaySearch_equals_holidayName_ara_pos: endPoint: /v1/masterdata/holidays/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/HolidaySearch/holidaySearch @@ -64,16 +60,11 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "holidayId": "$IGNORE$", - "name": "$IGNORE$", - "holidayDate": "2020-08-15", - "holidayName": "AutoTest user Ara", - "holidayDesc": "$IGNORE$", - "langCode": "ara" }' MasterData_HolidaySearch_startsWith_holidayName_eng_pos: endPoint: /v1/masterdata/holidays/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/HolidaySearch/holidaySearch @@ -100,16 +91,11 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "holidayId": "$IGNORE$", - "name": "$IGNORE$", - "holidayDate": "2020-08-15", - "holidayName": "AutoTest user Eng", - "holidayDesc": "$IGNORE$", - "langCode": "eng" }' MasterData_HolidaySearch_startsWith_holidayName_ara_pos: endPoint: /v1/masterdata/holidays/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/HolidaySearch/holidaySearch @@ -136,16 +122,11 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "holidayId": "$IGNORE$", - "name": "$IGNORE$", - "holidayDate": "2020-08-15", - "holidayName": "AutoTest user Ara", - "holidayDesc": "$IGNORE$", - "langCode": "ara" }' MasterData_HolidaySearch_contains_holidayName_eng_pos: endPoint: /v1/masterdata/holidays/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/HolidaySearch/holidaySearch @@ -172,12 +153,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "holidayId": "$IGNORE$", - "name": "$IGNORE$", - "holidayDate": "2020-08-15", - "holidayName": "$IGNORE$", - "holidayDesc": "$IGNORE$", - "langCode": "eng" }' diff --git a/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs b/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs index c240395d035..d13595944a3 100644 --- a/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs @@ -1,22 +1,9 @@ { - "id": "string", - "version": "string", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "isActive": {{isActive}}, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", + "isActive": "{{isActive}}", "holidayId": "{{holidayId}}", "name": "{{name}}", "holidayDate": "{{holidayDate}}", @@ -27,6 +14,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs b/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs index 2d0b9b487ef..10812b00af3 100644 --- a/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs +++ b/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs @@ -1,20 +1,6 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ - "id": "$IGNORE$", - "idVersion": $IGNORE$, "title": "{{title}}", - "description": "{{description}}", - "schemaJson": "$IGNORE$" - "status": "$IGNORE$", - "effectiveFrom": "$IGNORE$", - "createdBy": "$IGNORE$", - "updatedBy": "$IGNORE$", - "createdOn": "$IGNORE$", - "updatedOn": "$IGNORE$" -}, -"errors":"$IGNORE$" + "description": "{{description}}" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Language/languageResult.hbs b/automationtests/src/main/resources/masterdata/Language/languageResult.hbs index e401ccc9364..f662a23a4b4 100644 --- a/automationtests/src/main/resources/masterdata/Language/languageResult.hbs +++ b/automationtests/src/main/resources/masterdata/Language/languageResult.hbs @@ -1,10 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code": "{{code}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs b/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs index 0c2fe7c27db..291f2af58f0 100644 --- a/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs +++ b/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs @@ -1,22 +1,11 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "isActive":"{{isActive}}", -"createdBy":"$IGNORE$", -"createdDateTime":"$IGNORE$", -"updatedBy":"$IGNORE$", -"updatedDateTime":"$IGNORE$", -"isDeleted":"$IGNORE$", -"deletedDateTime":"$IGNORE$", "code":"{{code}}", "name":"{{name}}", "hierarchyLevel":{{hierarchyLevel}}, "hierarchyName":"{{hierarchyName}}", "parentLocCode":"{{parentLocCode}}", "langCode":"{{langCode}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs b/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs index 43ed584b5e7..c3475f33110 100644 --- a/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs +++ b/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs @@ -1,8 +1,4 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "id":"{{id}}", "name":"{{name}}", @@ -12,15 +8,6 @@ "ipAddress":"{{ipAddress}}", "langCode":"{{langCode}}", "validityDateTime":"{{validityDateTime}}", -"isActive":"{{isActive}}", -"createdBy":"$IGNORE$", -"createdDateTime":"$IGNORE$", -"updatedBy":"$IGNORE$", -"updatedDateTime":"$IGNORE$", -"isDeleted":"$IGNORE$", -"deletedDateTime":"$IGNORE$", -"regCenterId":"$IGNORE$", -"signPublicKey":"$IGNORE$" -}, -"errors":"$IGNORE$" +"isActive":"{{isActive}}" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs index cc257ce817b..9be53d201f0 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs b/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs b/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs index 2a3b5ce19ea..2e609f360a2 100644 --- a/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs @@ -1,22 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", "createdBy": "{{createdBy}}", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "code": "{{code}}", "langCode": "{{langCode}}", "name": "{{name}}", @@ -25,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs index d6832a588f4..8992fbe1aa7 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs index 551bcc91374..02e49d009ae 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs @@ -1,12 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "rsnCatCode": "{{rsnCatCode}}", "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs index e0381953f1d..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs index 31bb3911ca0..d178b3252a5 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs @@ -1,64 +1,13 @@ { - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "id": "$IGNORE$", "name": "{{name}}", - "centerTypeCode": "$IGNORE$", - "centerTypeName": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "holidayLocation": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "{{langCode}}", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "devices": "$IGNORE$", - "machines": "$IGNORE$", - "users": "$IGNORE$", - "province": "$IGNORE$", - "provinceCode": "$IGNORE$", - "region": "$IGNORE$", - "regionCode": "$IGNORE$", - "postalCode": "$IGNORE$", - "administrativeZone": "$IGNORE$", - "administrativeZoneCode": "$IGNORE$", - "city": "$IGNORE$", - "cityCode": "$IGNORE$", - "zoneCode": "$IGNORE$", - "zone": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": "$IGNORE$" + "langCode": "{{langCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/registrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/RegistrationCenter/registrationCenterResult.hbs index f0b49e09f4f..82c005bea55 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/registrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/registrationCenterResult.hbs @@ -1,46 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ - "id": "$IGNORE$", - "name": "{{name}}", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks":"$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": [ - { - "exceptionHolidayDate": "$IGNORE$", - "exceptionHolidayName": "$IGNORE$", - "exceptionHolidayReson": "$IGNORE$" - } - ] - }, -"errors":"$IGNORE$" + "name": "{{name}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs index f0b49e09f4f..82c005bea55 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs @@ -1,46 +1,5 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ - "id": "$IGNORE$", - "name": "{{name}}", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks":"$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": [ - { - "exceptionHolidayDate": "$IGNORE$", - "exceptionHolidayName": "$IGNORE$", - "exceptionHolidayReson": "$IGNORE$" - } - ] - }, -"errors":"$IGNORE$" + "name": "{{name}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs b/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs index fcbbee2bbe1..0b6622e68bd 100644 --- a/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs +++ b/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs @@ -1,12 +1,7 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "rsnCatCode": "{{rsnCatCode}}", "code": "{{code}}", "langCode": "{{langCode}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs b/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs index 1bef69c3fcc..c52e067ea94 100644 --- a/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs +++ b/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs @@ -1,11 +1,6 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "code": "{{code}}", "langCode": "{{langCode}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ResumePacketWorkflow/resumePacketResult.hbs b/automationtests/src/main/resources/masterdata/ResumePacketWorkflow/resumePacketResult.hbs index 077404aaa41..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/ResumePacketWorkflow/resumePacketResult.hbs +++ b/automationtests/src/main/resources/masterdata/ResumePacketWorkflow/resumePacketResult.hbs @@ -1,3 +1 @@ -{ - -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs index b94198d8a75..a2d1d6b36f9 100644 --- a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs @@ -1,22 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "word": "{{word}}", "langCode": "{{langCode}}", "description": "{{description}}" @@ -24,6 +11,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs b/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs index c11ddc3756f..b3375ab0b23 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs @@ -1,22 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "code": "{{code}}", "name": "{{name}}", "langCode": "{{langCode}}", @@ -25,6 +12,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs index c11ddc3756f..b3375ab0b23 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs @@ -1,22 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "code": "{{code}}", "name": "{{name}}", "langCode": "{{langCode}}", @@ -25,6 +12,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs index dc3f74eae34..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs @@ -1,36 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", - "data": [ - {{#each data}} - { - "code": "$IGNORE$", - "description": "$IGNORE$", - "documentType": { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$" - }, - "isActive": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs index c11ddc3756f..b3375ab0b23 100644 --- a/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs @@ -1,22 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "code": "{{code}}", "name": "{{name}}", "langCode": "{{langCode}}", @@ -25,6 +12,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs b/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs index 91d29bc1abf..a56a87a7f1a 100644 --- a/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs @@ -1,16 +1,8 @@ { - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", "isActive": {{isActive}}, "region": "{{region}}", "city": "{{city}}", @@ -21,6 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml index 095fcd2261d..3f7837061f5 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml @@ -2,6 +2,7 @@ SearchMachine: Masterdata_SearchMachine_Valid_Smoke: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -28,24 +29,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "Mach-Test", - "serialNum": "FB5962911687", - "macAddress": "61-D3-FD-12-C9-ED", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_FilterTypeContains: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -72,24 +60,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "Mach-Test", - "serialNum": "FB5962911687", - "macAddress": "61-D3-FD-12-C9-ED", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_FilterTypeStartsWith: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -116,20 +91,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "NLT updated", - "serialNum": "FB5962911687", - "macAddress": "61-D3-FD-12-C9-ED", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNFilterTypeEquals: endPoint: /v1/masterdata/machines/search @@ -266,6 +227,7 @@ SearchMachine: Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeEquals: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -292,24 +254,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "FB5962911687", - "macAddress": "$IGNORE$", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeContains: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -336,24 +285,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "FB5962911687", - "macAddress": "$IGNORE$", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeStartsWith: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -380,24 +316,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "FB5962911687", - "macAddress": "$IGNORE$", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeEquals: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -424,24 +347,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "FB5962911687", - "macAddress": "$IGNORE$", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeContains: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -468,24 +378,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "FB5962911687", - "macAddress": "$IGNORE$", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeStartsWith: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -512,24 +409,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "FB5962911687", - "macAddress": "$IGNORE$", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_TwoFilterValues_TypeEqualsNEquals: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -563,24 +447,11 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "Mach-Test", - "serialNum": "FB5962911687", - "macAddress": "61-D3-FD-12-C9-ED", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_SortFieldDESC: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -607,20 +478,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "Mach-Test", - "serialNum": "FB5962911687", - "macAddress": "61-D3-FD-12-C9-ED", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Valid_TwoSortFields_DescNDesc: endPoint: /v1/masterdata/machines/search @@ -673,6 +530,7 @@ SearchMachine: Masterdata_SearchMachine_Valid_TwoSortFields_AscNDesc: endPoint: /v1/masterdata/machines/search role: globalAdmin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchMachine/searchMachine @@ -703,20 +561,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "id": "$IGNORE$", - "name": "Mach-Test", - "serialNum": "FB5962911687", - "macAddress": "61-D3-FD-12-C9-ED", - "ipAddress": "192.168.0.424", - "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "CST", - "zone": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] }' Masterdata_SearchMachine_Invalid_ColumnName: endPoint: /v1/masterdata/machines/search diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs index 5b1c05c3b07..4a030d6e0b3 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs @@ -1,20 +1,8 @@ { - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "id": "{{id}}", "name": "{{name}}", "serialNum": "{{serialNum}}", @@ -29,6 +17,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs index 941b2bc0a3e..47b22cd1d4c 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs @@ -1,21 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "isActive": "{{isActive}}", "id": "{{id}}", "langCode": "{{langCode}}", @@ -29,6 +16,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs b/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs index 38ebfe90aa2..a45d93e7493 100644 --- a/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs @@ -1,31 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "workflowId": "$IGNORE$", - "statusCode": "{{statusCode}}", - "statusComment": "$IGNORE$", - "createdBy": "$IGNORE$", - "createDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "workflowType": "$IGNORE$", - "updateDateTime": "$IGNORE$", - "currentStageName": "$IGNORE$", - "resumeTimestamp": "$IGNORE$", - "defaultResumeAction": "$IGNORE$", - "pauseRuleIds": "$IGNORE$", - "lastSuccessStageName": "$IGNORE$" + "statusCode": "{{statusCode}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs index c3464f92e75..8140d314f13 100644 --- a/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs @@ -1,17 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", "code": "{{code}}", "name": "{{name}}", "descr": "{{descr}}", diff --git a/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs b/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs index 0369f3d0220..410852aa04a 100644 --- a/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs @@ -1,29 +1,17 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "id": "{{id}}", - "name": "{{name}}", + "name": "{{name}}", "description": "{{description}}", - "fileFormatCode": "{{fileFormatCode}}", + "fileFormatCode": "{{fileFormatCode}}", "model": "{{model}}", "fileText": "{{fileText}}", "moduleId": "{{moduleId}}", - "moduleName": "{{moduleName}}", + "moduleName": "{{moduleName}}", "templateTypeCode": "{{templateTypeCode}}", "langCode": "{{langCode}}" } diff --git a/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs index 7b3f3df2392..0221a21aeb3 100644 --- a/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs @@ -1,25 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "userId": "{{userId}}", - "userName": "$IGNORE$", - "regCenterName": "$IGNORE$", "zoneName": "{{zoneName}}", "regCenterId": "{{regCenterId}}", "zoneCode": "{{zoneCode}}" @@ -27,6 +11,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs b/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs index 55fb0275e44..8d6eb1354fc 100644 --- a/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs @@ -1,11 +1,5 @@ { - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { @@ -18,6 +12,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Template/templateResult.hbs b/automationtests/src/main/resources/masterdata/Template/templateResult.hbs index cc257ce817b..9be53d201f0 100644 --- a/automationtests/src/main/resources/masterdata/Template/templateResult.hbs +++ b/automationtests/src/main/resources/masterdata/Template/templateResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Title/titleResult.hbs b/automationtests/src/main/resources/masterdata/Title/titleResult.hbs index e857d744f99..1c6a42c563e 100644 --- a/automationtests/src/main/resources/masterdata/Title/titleResult.hbs +++ b/automationtests/src/main/resources/masterdata/Title/titleResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "code": "{{code}}", "langCode": "{{langCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs b/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs index e0381953f1d..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs b/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs index 8fc774b394c..e229a753296 100644 --- a/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs @@ -1,22 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { "isActive": "{{isActive}}", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "{{code}}", + "code": "{{code}}", "titleName": "{{titleName}}", "titleDescription": "{{titleDescription}}", "langCode": "{{langCode}}" diff --git a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs index 785daa1b983..e0205766751 100644 --- a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs @@ -1,11 +1,6 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", "response":{ "word":"{{word}}", "langCode":"{{langCode}}" -}, -"errors":"$IGNORE$" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordStatus/updateBlockListedWordStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordStatus/updateBlockListedWordStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordStatus/updateBlockListedWordStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordStatus/updateBlockListedWordStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceSpecStatus/updateDeviceSpecStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceSpecStatus/updateDeviceSpecStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceSpecStatus/updateDeviceSpecStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceSpecStatus/updateDeviceSpecStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDynamicFieldStatus/updateDynamicFieldStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDynamicFieldStatus/updateDynamicFieldStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDynamicFieldStatus/updateDynamicFieldStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDynamicFieldStatus/updateDynamicFieldStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs b/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs b/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegCentStatus/updateRegCentStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegCentStatus/updateRegCentStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegCentStatus/updateRegCentStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegCentStatus/updateRegCentStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml index 3d04cfa53ee..dc7a20f74fe 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml @@ -17,7 +17,7 @@ UpdateRegistrationCenterLang: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "10008", + "id": "$IGNORE$", "name": "Center Sidi Allal Tazi Test", "addressLine1": "National Road Test", "addressLine2": "Alla Tazi Test", diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs index c7f78fc2d1c..a0bbe3e300a 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs @@ -1,40 +1,11 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "id": "{{id}}", "name": "{{name}}", - "centerTypeCode": "$IGNORE$", "addressLine1": "{{addressLine1}}", "addressLine2": "{{addressLine2}}", "addressLine3": "{{addressLine3}}", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", "langCode": "{{langCode}}", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "{{contactPerson}}", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": "$IGNORE$" - }, - "errors": "$IGNORE$" + "contactPerson": "{{contactPerson}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/UpdateRegistrationCenterNonLanguage.yml b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/UpdateRegistrationCenterNonLanguage.yml index 6e0e1a2f335..f52c340fbae 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/UpdateRegistrationCenterNonLanguage.yml +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/UpdateRegistrationCenterNonLanguage.yml @@ -12,7 +12,7 @@ UpdateRegistrationCenterNonLanguage: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "10008", + "id": "$IGNORE$", "contactPhone": "9663089998", "centerTypeCode": "REG" }' diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs index 0bb6eb03d92..700e81d1638 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs @@ -1,51 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", "id": "{{id}}", - "name": "$IGNORE$", "centerTypeCode": "{{centerTypeCode}}", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", "contactPhone": "{{contactPhone}}", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": 0, - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": [ - { - "exceptionHolidayDate": "$IGNORE$", - "exceptionHolidayName": "$IGNORE$", - "exceptionHolidayReson": "$IGNORE$" - }, - { - "exceptionHolidayDate": "$IGNORE$", - "exceptionHolidayName": "$IGNORE$", - "exceptionHolidayReson": "$IGNORE$" - } - ] - }, - "errors": "$IGNORE$" + "numberOfKiosks": 0 + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateTemplateFileFormatStatus/updateTemplateFileFormatStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateTemplateFileFormatStatus/updateTemplateFileFormatStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateTemplateFileFormatStatus/updateTemplateFileFormatStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateTemplateFileFormatStatus/updateTemplateFileFormatStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs b/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateWorkingDay/updateWorkingDayResult.hbs b/automationtests/src/main/resources/masterdata/UpdateWorkingDay/updateWorkingDayResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateWorkingDay/updateWorkingDayResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateWorkingDay/updateWorkingDayResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateWorkingDayStatus/updateWorkingDayStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateWorkingDayStatus/updateWorkingDayStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateWorkingDayStatus/updateWorkingDayStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateWorkingDayStatus/updateWorkingDayStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs index 325f1e80e72..0137f52daaa 100644 --- a/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs index 9fdd9da5ba8..544dac6f1f4 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs @@ -1,18 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}", "name": "{{name}}", "statusCode": "{{statusCode}}", "regCenterId": "{{regCenterId}}", - "isActive": $IGNORE$, "zoneCode": "{{zoneCode}}", "zoneName": "{{zoneName}}", "regCenterName": "{{regCenterName}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs index 4207ef08449..985171e42f8 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "docTypeCode": "{{docTypeCode}}", "docCategoryCode": "{{docCategoryCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs index d3369d3329c..3187675d832 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}", "message": "{{message}}" - }, - "errors": $IGNORE$ + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs index dc3f74eae34..0967ef424bc 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs @@ -1,36 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", - "data": [ - {{#each data}} - { - "code": "$IGNORE$", - "description": "$IGNORE$", - "documentType": { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$" - }, - "isActive": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} +{} diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs index d3369d3329c..3187675d832 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}", "message": "{{message}}" - }, - "errors": $IGNORE$ + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs b/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs index 7617d3c05e5..903ab78f706 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "zoneCode": "{{zoneCode}}", "userId": "{{userId}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/error.hbs b/automationtests/src/main/resources/masterdata/error.hbs index 04f0f8e99d2..f4bcb6bee67 100644 --- a/automationtests/src/main/resources/masterdata/error.hbs +++ b/automationtests/src/main/resources/masterdata/error.hbs @@ -1,12 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "message": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs b/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs index cb7b8b0b8f7..805a7afa760 100644 --- a/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "registrationCenters": [ @@ -10,14 +6,10 @@ { "cntrId": "{{cntrId}}", "machineId": "{{machineId}}", - "usrId": "{{usrId}}", - "isActive": $IGNORE$, - "langCode": "$IGNORE$", - "effectivetimes": "$IGNORE$" + "usrId": "{{usrId}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file From 246d2cb1780bfd997845f05469ef8cb6bccf9d55 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Thu, 24 Aug 2023 19:54:04 +0530 Subject: [PATCH 070/204] MOSIP-29080 --- .../fw/util/OutputValidationUtil.java | 3 + .../addLostUinApplicationResult.hbs | 13 +-- .../addUpdateRegistrationResult.hbs | 12 +-- .../bookMultipleAppointmentResult.hbs | 6 +- .../cancelApplicationsAppointmentResult.hbs | 7 +- .../cancelAppointmentResult.hbs | 7 +- .../CopyDocument/copyDocumentResult.hbs | 12 +-- .../deleteAllDocForaPRIDResult.hbs | 6 +- .../DeleteBooking/deleteBookingResult.hbs | 10 +- .../DeleteLostUinApplication.yml | 3 +- .../deleteLostUinApplicationResult.hbs | 10 +- .../deletePreRegistrationResult.hbs | 10 +- .../deleteSpecificDocForaPRIDResult.hbs | 6 +- .../fetchApplicationByPridResult.hbs | 91 ----------------- .../fetchAppointmentDetailsByPridResult.hbs | 11 +-- .../GetAllApplications/GetAllApplications.yml | 11 +-- .../getAllApplicationsResult.hbs | 22 ----- .../GetAllDocForPrId/GetAllDocForPrId.yml | 5 +- .../getAllDocForPrIdResult.hbs | 11 +-- .../GetAllPreRegApplications.yml | 1 + .../GetAllPreRegApplicationsResult.hbs | 22 ----- .../getApplicationStatusWithPrIdResult.hbs | 9 +- .../getApplicationWithPrIdResult.hbs | 8 -- .../getAppointmentDetailsResult.hbs | 11 +-- .../getAvailableSlotForRegCentreIdResult.hbs | 10 +- .../GetPRIDByDateRange/GetPRIDByDateRange.yml | 9 +- .../getPRIDByDateRangeResult.hbs | 9 +- .../getPRIDForRegCentResult.hbs | 9 +- .../getPreRegInfoByPridResult.hbs | 58 ----------- .../GetSpecificDocumentforaPRID.yml | 1 + .../getSpecificDocumentforaPRIDResult.hbs | 6 +- .../GetUpdatedDateTimeByPrid.yml | 2 +- .../getUpdatedDateTimeByPridResult.hbs | 5 - .../InvalidateToken/invalidatetokenresult.hbs | 3 - .../SendNotifications/SendNotifications.yml | 4 +- .../sendNotificationsNotify.hbs | 3 - .../sendNotificationsResult.hbs | 6 +- .../preReg/SendOtp/sendotpResult.hbs | 6 +- .../Transliteration/translateResult.hbs | 6 +- .../UpdateDocRefID/updateDocRefIDResult.hbs | 4 - .../updatePreRegStatusResult.hbs | 6 +- .../UpdatePreregistration.yml | 6 +- .../updatePreregistrationResult.hbs | 92 +---------------- .../preReg/ValidateOtp/validateOtpResult.hbs | 6 +- .../bookAppointment/bookAppointment.yml | 16 +-- .../bookAppointment/bookAppointmentResult.hbs | 7 +- .../bookAppointmentByPRID.yml | 8 +- .../bookAppointmentByPRIDResult.hbs | 3 - .../preReg/createPrereg/createPrereg.yml | 16 +-- .../createPrereg/createPreregResult.hbs | 98 ------------------- .../src/main/resources/preReg/error.hbs | 10 +- .../preReg/uploadDocument/uploadDocument.yml | 20 ++-- .../uploadDocument/uploadDocumentResult.hbs | 8 +- 53 files changed, 86 insertions(+), 658 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index 970dbaff69d..ef9294cb781 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -84,6 +84,9 @@ public static void setLogLevel() { */ public static Map> compareActuExpValue(Map actual, Map exp, String actVsExp) { + if(actual == null || exp == null) + throw new SkipException("Marking testcase as Skipped, as no Output comparison done"); + Map> objMap = new HashMap<>(); List objList = new ArrayList(); boolean comparisonDone = false; diff --git a/automationtests/src/main/resources/preReg/AddLostUinApplication/addLostUinApplicationResult.hbs b/automationtests/src/main/resources/preReg/AddLostUinApplication/addLostUinApplicationResult.hbs index 549262f6585..c9bc8b39df3 100644 --- a/automationtests/src/main/resources/preReg/AddLostUinApplication/addLostUinApplicationResult.hbs +++ b/automationtests/src/main/resources/preReg/AddLostUinApplication/addLostUinApplicationResult.hbs @@ -1,17 +1,6 @@ { - "id": "mosip.pre-registration.lostuin.create", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "applicationId": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", "applicationStatusCode": "{{applicationStatusCode}}", - "bookingStatusCode": "$IGNORE$", - "langCode": "$IGNORE$", "bookingType": "{{bookingType}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs b/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs index 6c2224309e1..ee436d9403f 100644 --- a/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs +++ b/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs @@ -1,17 +1,7 @@ { - "id": "mosip.pre-registration.updateregistration.create", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "applicationId": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", "applicationStatusCode": "{{applicationStatusCode}}", - "bookingStatusCode": "$IGNORE$", "langCode": "$IGNORE$", "bookingType": "{{bookingType}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/BookMultipleAppointment/bookMultipleAppointmentResult.hbs b/automationtests/src/main/resources/preReg/BookMultipleAppointment/bookMultipleAppointmentResult.hbs index e589c78d142..4e4d62b305e 100644 --- a/automationtests/src/main/resources/preReg/BookMultipleAppointment/bookMultipleAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/BookMultipleAppointment/bookMultipleAppointmentResult.hbs @@ -1,7 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "bookingStatusResponse": [ { @@ -11,6 +8,5 @@ "bookingMessage": "{{bookingMessage}}" } ] - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs b/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs index 419b1f0f580..ba212b70ab8 100644 --- a/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "message": "{{message}}" - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs b/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs index 419b1f0f580..ba212b70ab8 100644 --- a/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "message": "{{message}}" - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CopyDocument/copyDocumentResult.hbs b/automationtests/src/main/resources/preReg/CopyDocument/copyDocumentResult.hbs index f49667b8987..c8f97455235 100644 --- a/automationtests/src/main/resources/preReg/CopyDocument/copyDocumentResult.hbs +++ b/automationtests/src/main/resources/preReg/CopyDocument/copyDocumentResult.hbs @@ -1,14 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "preRegistrationId": "$IGNORE$", - "docId": "$IGNORE$", - "docName": "$IGNORE$", "docCatCode": "{{docCatCode}}", - "docTypCode": "{{docTypCode}}", - "docFileFormat": "$IGNORE$" - }, - "errors": null + "docTypCode": "{{docTypCode}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs b/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs index 1b91dbcbcde..ba212b70ab8 100644 --- a/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version" : "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors":null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteBooking/deleteBookingResult.hbs b/automationtests/src/main/resources/preReg/DeleteBooking/deleteBookingResult.hbs index 193c1b19e5d..ad158d3d0d7 100644 --- a/automationtests/src/main/resources/preReg/DeleteBooking/deleteBookingResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteBooking/deleteBookingResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "preRegistrationId": "$IGNORE$", - "deletedBy": "{{deletedBy}}", - "deletedDateTime": "$IGNORE$" - }, - "errors": null + "deletedBy": "{{deletedBy}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml b/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml index 2b1790be430..5b79f404c9a 100644 --- a/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml +++ b/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml @@ -2,6 +2,7 @@ DeleteLostUinApplication: Prereg_DeleteLostUinApplication_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg/{applicationId} role: batch + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: preReg/DeleteLostUinApplication/deleteLostUinApplication outputTemplate: preReg/DeleteLostUinApplication/deleteLostUinApplicationResult @@ -9,7 +10,7 @@ DeleteLostUinApplication: "applicationId": "$ID:CreatePrereg_Valid_Smoke_sid_preRegistrationId$" }' output: '{ -"deletedBy": "$IGNORE$" + "deletedBy": "$IGNORE$" }' Prereg_DeleteLostUinApplication_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/applications/prereg/{applicationId} diff --git a/automationtests/src/main/resources/preReg/DeleteLostUinApplication/deleteLostUinApplicationResult.hbs b/automationtests/src/main/resources/preReg/DeleteLostUinApplication/deleteLostUinApplicationResult.hbs index c2cf5927d7c..0fac661eed6 100644 --- a/automationtests/src/main/resources/preReg/DeleteLostUinApplication/deleteLostUinApplicationResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteLostUinApplication/deleteLostUinApplicationResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "applicationId": "$IGNORE$", - "deletedBy": "{{deletedBy}}", - "deletedDateTime": "$IGNORE$" - }, - "errors": null + "deletedBy": "{{deletedBy}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeletePreRegistration/deletePreRegistrationResult.hbs b/automationtests/src/main/resources/preReg/DeletePreRegistration/deletePreRegistrationResult.hbs index f5b2324501c..0fac661eed6 100644 --- a/automationtests/src/main/resources/preReg/DeletePreRegistration/deletePreRegistrationResult.hbs +++ b/automationtests/src/main/resources/preReg/DeletePreRegistration/deletePreRegistrationResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "preRegistrationId": "$IGNORE$", - "deletedBy": "{{deletedBy}}", - "deletedDateTime": "$IGNORE$" - }, - "errors": null + "deletedBy": "{{deletedBy}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs index 276349a447b..ba212b70ab8 100644 --- a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version" : "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/FetchApplicationByPrid/fetchApplicationByPridResult.hbs b/automationtests/src/main/resources/preReg/FetchApplicationByPrid/fetchApplicationByPridResult.hbs index 88206ed5ba1..3032571e178 100644 --- a/automationtests/src/main/resources/preReg/FetchApplicationByPrid/fetchApplicationByPridResult.hbs +++ b/automationtests/src/main/resources/preReg/FetchApplicationByPrid/fetchApplicationByPridResult.hbs @@ -1,101 +1,10 @@ { - "id": "mosip.pre-registration.demographic.retrieve.details", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "preRegistrationId": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "statusCode": "$IGNORE$", - "langCode": "$IGNORE$", "demographicDetails": { "identity": { - "gender": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "city": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "postalCode": "14022", - "fullName": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "dateOfBirth": "1996/01/01", - "IDSchemaVersion": "$IGNORE$", - "province": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "zone": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "phone": "8249742850", - "addressLine1": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "residenceStatus": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "region": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "email": "goku@hogwarts.co.in" } } diff --git a/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/fetchAppointmentDetailsByPridResult.hbs b/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/fetchAppointmentDetailsByPridResult.hbs index 04e1335d6ba..556701d6072 100644 --- a/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/fetchAppointmentDetailsByPridResult.hbs +++ b/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/fetchAppointmentDetailsByPridResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version" : "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "registration_center_id": "{{registration_center_id}}", - "appointment_date": "$IGNORE$", - "time_slot_from": "$IGNORE$", - "time_slot_to": "$IGNORE$" - }, - "errors":null + "registration_center_id": "{{registration_center_id}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml b/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml index a2a9914321e..f6a3601d62e 100644 --- a/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml +++ b/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml @@ -2,6 +2,7 @@ GetAllApplications: Prereg_GetAllApplications_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/GetAllApplications/getAllApplications outputTemplate: preReg/GetAllApplications/getAllApplicationsResult @@ -9,7 +10,6 @@ GetAllApplications: "type": null }' output: '{ - "errors": null }' Prereg_GetAllApplications_InValid_Type: endPoint: /preregistration/v1/applications?type={type} @@ -31,6 +31,7 @@ GetAllApplications: Prereg_GetAllApplications_Valid_Type_Smoke_sid: endPoint: /preregistration/v1/applications?type={type} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/GetAllApplications/getAllApplications outputTemplate: preReg/GetAllApplications/getAllApplicationsResult @@ -38,12 +39,4 @@ GetAllApplications: "type": "NEW_PREREGISTRATION" }' output: '{ - "response": { - "allApplications":[ - { - "bookingType": "NEW_PREREGISTRATION" - } - ] - }, - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAllApplications/getAllApplicationsResult.hbs b/automationtests/src/main/resources/preReg/GetAllApplications/getAllApplicationsResult.hbs index 557af02180b..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/GetAllApplications/getAllApplicationsResult.hbs +++ b/automationtests/src/main/resources/preReg/GetAllApplications/getAllApplicationsResult.hbs @@ -1,24 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "allApplications": [ - {{#each allApplications}} - { - "applicationId": "$IGNORE$", - "bookingType": "{{bookingType}}", - "bookingStatusCode": "$IGNORE$", - "applicationStatusCode": "$IGNORE$", - "contactInfo": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtime": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtime": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": null } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml b/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml index aeef53ea5c9..9ab1a0991a3 100644 --- a/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml +++ b/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml @@ -2,6 +2,7 @@ GetAllDocForPrId: Prereg_GetAllDocForPrId_All_Valid_Smoke_sid: endPoint: /preregistration/v1/documents/preregistration/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/GetAllDocForPrId/getAllDocForPrId outputTemplate: preReg/GetAllDocForPrId/getAllDocForPrIdResult @@ -9,8 +10,8 @@ GetAllDocForPrId: "preRegistrationId": "$ID:CreatePrereg_All_Valid_Smoke_sid_preRegistrationId$" }' output: '{ - "docCatCode":"$IGNORE$", - "docTypCode":"$IGNORE$" + "docCatCode": "$IGNORE$", + "docTypCode": "$IGNORE$" }' Prereg_GetAllDocForPrId_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/documents/preregistration/{preRegistrationId} diff --git a/automationtests/src/main/resources/preReg/GetAllDocForPrId/getAllDocForPrIdResult.hbs b/automationtests/src/main/resources/preReg/GetAllDocForPrId/getAllDocForPrIdResult.hbs index 80d87aadd69..08b3e148303 100644 --- a/automationtests/src/main/resources/preReg/GetAllDocForPrId/getAllDocForPrIdResult.hbs +++ b/automationtests/src/main/resources/preReg/GetAllDocForPrId/getAllDocForPrIdResult.hbs @@ -1,17 +1,10 @@ { - "id": "$IGNORE$", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { "documentsMetaData": [ { - "docName": "$IGNORE$", - "documentId": "$IGNORE$", "docCatCode": "{{docCatCode}}", - "docTypCode": "{{docTypCode}}", - "langCode": "$IGNORE$" + "docTypCode": "{{docTypCode}}" } ] - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplications.yml b/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplications.yml index fa569abe086..59e716ddd5b 100644 --- a/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplications.yml +++ b/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplications.yml @@ -2,6 +2,7 @@ GetAllPreRegApplications: Prereg_GetAllPreRegApplications_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/GetAllPreRegApplications/getAllPreRegApplications outputTemplate: preReg/GetAllPreRegApplications/GetAllPreRegApplicationsResult diff --git a/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplicationsResult.hbs b/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplicationsResult.hbs index 557af02180b..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplicationsResult.hbs +++ b/automationtests/src/main/resources/preReg/GetAllPreRegApplications/GetAllPreRegApplicationsResult.hbs @@ -1,24 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "allApplications": [ - {{#each allApplications}} - { - "applicationId": "$IGNORE$", - "bookingType": "{{bookingType}}", - "bookingStatusCode": "$IGNORE$", - "applicationStatusCode": "$IGNORE$", - "contactInfo": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtime": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtime": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": null } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/getApplicationStatusWithPrIdResult.hbs b/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/getApplicationStatusWithPrIdResult.hbs index 68b5532af71..5bd4b5fb05f 100644 --- a/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/getApplicationStatusWithPrIdResult.hbs +++ b/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/getApplicationStatusWithPrIdResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.pre-registration.demographic.retrieve.status", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "statusCode": "{{statusCode}}", - "preRegistartionId": "$IGNORE$" - }, - "errors": null + "statusCode": "{{statusCode}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetApplicationWithPrId/getApplicationWithPrIdResult.hbs b/automationtests/src/main/resources/preReg/GetApplicationWithPrId/getApplicationWithPrIdResult.hbs index 770451819df..e2a27c29bce 100644 --- a/automationtests/src/main/resources/preReg/GetApplicationWithPrId/getApplicationWithPrIdResult.hbs +++ b/automationtests/src/main/resources/preReg/GetApplicationWithPrId/getApplicationWithPrIdResult.hbs @@ -1,13 +1,5 @@ { - "id": "mosip.pre-registration.demographic.retrieve.details", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "preRegistrationId": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", "statusCode": "{{statusCode}}", "langCode": "{{langCode}}", "demographicDetails": { diff --git a/automationtests/src/main/resources/preReg/GetAppointmentDetails/getAppointmentDetailsResult.hbs b/automationtests/src/main/resources/preReg/GetAppointmentDetails/getAppointmentDetailsResult.hbs index 04e1335d6ba..556701d6072 100644 --- a/automationtests/src/main/resources/preReg/GetAppointmentDetails/getAppointmentDetailsResult.hbs +++ b/automationtests/src/main/resources/preReg/GetAppointmentDetails/getAppointmentDetailsResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version" : "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "registration_center_id": "{{registration_center_id}}", - "appointment_date": "$IGNORE$", - "time_slot_from": "$IGNORE$", - "time_slot_to": "$IGNORE$" - }, - "errors":null + "registration_center_id": "{{registration_center_id}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/getAvailableSlotForRegCentreIdResult.hbs b/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/getAvailableSlotForRegCentreIdResult.hbs index f3e62486820..5ef68303359 100644 --- a/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/getAvailableSlotForRegCentreIdResult.hbs +++ b/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/getAvailableSlotForRegCentreIdResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "regCenterId": "{{regCenterId}}", - "centerDetails": "$IGNORE$" - }, - "errors": "$IGNORE$" + "regCenterId": "{{regCenterId}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml b/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml index 46f0d1913ff..366ba1d8609 100644 --- a/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml +++ b/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml @@ -165,8 +165,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_003", - "message": "$IGNORE$" + "errorCode": "PRG_PAM_CORE_003" } ] }' @@ -187,8 +186,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_003", - "message": "$IGNORE$" + "errorCode": "PRG_PAM_CORE_003" } ] }' @@ -209,8 +207,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_015", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_015" } ] }' diff --git a/automationtests/src/main/resources/preReg/GetPRIDByDateRange/getPRIDByDateRangeResult.hbs b/automationtests/src/main/resources/preReg/GetPRIDByDateRange/getPRIDByDateRangeResult.hbs index 89dd0d5621c..2addbfee983 100644 --- a/automationtests/src/main/resources/preReg/GetPRIDByDateRange/getPRIDByDateRangeResult.hbs +++ b/automationtests/src/main/resources/preReg/GetPRIDByDateRange/getPRIDByDateRangeResult.hbs @@ -1,11 +1,4 @@ { - "id": "{{id}}", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", - "countOfPreRegIds": "$IGNORE$", - "preRegistrationIds": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetPRIDForRegCent/getPRIDForRegCentResult.hbs b/automationtests/src/main/resources/preReg/GetPRIDForRegCent/getPRIDForRegCentResult.hbs index 67468c674c2..556701d6072 100644 --- a/automationtests/src/main/resources/preReg/GetPRIDForRegCent/getPRIDForRegCentResult.hbs +++ b/automationtests/src/main/resources/preReg/GetPRIDForRegCent/getPRIDForRegCentResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "registration_center_id": "{{registration_center_id}}", - "pre_registration_ids": "$IGNORE$" - }, - "errors": "$IGNORE$" + "registration_center_id": "{{registration_center_id}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/getPreRegInfoByPridResult.hbs b/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/getPreRegInfoByPridResult.hbs index 7dca86faa73..849334514ea 100644 --- a/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/getPreRegInfoByPridResult.hbs +++ b/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/getPreRegInfoByPridResult.hbs @@ -1,69 +1,11 @@ { - "version": "1.0", - "responsetime": "$IGNORE$", "response": { "demographicResponse": { - "preRegistrationId": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "statusCode": "$IGNORE$", - "langCode": "$IGNORE$", "demographicDetails": { "identity": { - "gender": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "city": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "postalCode": "14022", - "fullName": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "dateOfBirth": "1996/01/01", - "IDSchemaVersion": "$IGNORE$", - "province": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "zone": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "phone": "8249742850", - "addressLine1": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "residenceStatus": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "region": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], "email": "goku@hogwarts.co.in" } } diff --git a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml index a0698888081..ea03f2a7382 100644 --- a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml +++ b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml @@ -11,6 +11,7 @@ GetSpecificDocumentforaPRID: "documentId": "$ID:UploadDocument_All_Valid_Smoke_sid_docId$" }' output: '{ + "document": "$IGNORE$" }' Prereg_GetSpecificDocumentforaPRID_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/documents/{documentId}?preRegistrationId={preRegistrationId} diff --git a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/getSpecificDocumentforaPRIDResult.hbs b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/getSpecificDocumentforaPRIDResult.hbs index 7ef60baebc3..7a7c6c63455 100644 --- a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/getSpecificDocumentforaPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/getSpecificDocumentforaPRIDResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "document": "{{document}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml b/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml index 04cbf3c5954..05f78f8eaba 100644 --- a/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml +++ b/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml @@ -2,6 +2,7 @@ GetUpdatedDateTimeByPrid: Prereg_GetUpdatedDateTimeByPrid_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg/updatedTime role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/GetUpdatedDateTimeByPrid/getUpdatedDateTimeByPrid outputTemplate: preReg/GetUpdatedDateTimeByPrid/getUpdatedDateTimeByPridResult @@ -23,7 +24,6 @@ GetUpdatedDateTimeByPrid: ] }' output: '{ - "errors": null }' Prereg_GetUpdatedDateTimeByPrid_InValid_ID: endPoint: /preregistration/v1/applications/prereg/updatedTime diff --git a/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/getUpdatedDateTimeByPridResult.hbs b/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/getUpdatedDateTimeByPridResult.hbs index d865f84189f..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/getUpdatedDateTimeByPridResult.hbs +++ b/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/getUpdatedDateTimeByPridResult.hbs @@ -1,7 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": "$IGNORE$", - "errors": null } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/InvalidateToken/invalidatetokenresult.hbs b/automationtests/src/main/resources/preReg/InvalidateToken/invalidatetokenresult.hbs index d976bf3a0c4..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/preReg/InvalidateToken/invalidatetokenresult.hbs +++ b/automationtests/src/main/resources/preReg/InvalidateToken/invalidatetokenresult.hbs @@ -1,6 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml b/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml index 6e067e86270..a687f8d6bcf 100644 --- a/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml +++ b/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml @@ -91,8 +91,8 @@ SendNotifications: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "$IGNORE$" + "errorCode": "PRG_PAM_APP_005" + } ] }' diff --git a/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsNotify.hbs b/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsNotify.hbs index adcefeb6767..a9562e2020f 100644 --- a/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsNotify.hbs +++ b/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsNotify.hbs @@ -1,6 +1,4 @@ { - "id":"{{id}}", - "version":"{{version}}", "requesttime":"{{requesttime}}", "request":{ "name":"{{name}}", @@ -9,7 +7,6 @@ "appointmentTime":"{{appointmentTime}}", "mobNum":"{{mobNum}}", "emailID":"{{emailID}}", - "additionalRecipient":null, "isBatch":{{isBatch}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs b/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs index f5ff423f76f..ba212b70ab8 100644 --- a/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs +++ b/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs b/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs index cae0777969c..e9916f7c67c 100644 --- a/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs +++ b/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs @@ -1,10 +1,6 @@ { - "id": "mosip.pre-registration.login.sendotp", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { "message": "{{message}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/Transliteration/translateResult.hbs b/automationtests/src/main/resources/preReg/Transliteration/translateResult.hbs index f1ab9dca48b..0b9563a103e 100644 --- a/automationtests/src/main/resources/preReg/Transliteration/translateResult.hbs +++ b/automationtests/src/main/resources/preReg/Transliteration/translateResult.hbs @@ -1,12 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "from_field_value": "{{from_field_value}}", "from_field_lang": "{{from_field_lang}}", "to_field_value": "{{to_field_value}}", "to_field_lang": "{{to_field_lang}}" - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs b/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs index d865f84189f..297ff8b24e5 100644 --- a/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs +++ b/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs @@ -1,7 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": "$IGNORE$", "errors": null } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs b/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs index 2c136adb7c8..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs +++ b/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs @@ -1,7 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml b/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml index e62b9f6ebcd..a5771d5a7c6 100644 --- a/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml +++ b/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml @@ -218,8 +218,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_015", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_015" } ] }' @@ -244,8 +243,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_003", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_003" } ] }' diff --git a/automationtests/src/main/resources/preReg/UpdatePreregistration/updatePreregistrationResult.hbs b/automationtests/src/main/resources/preReg/UpdatePreregistration/updatePreregistrationResult.hbs index f12b31b91c3..00a7c85075b 100644 --- a/automationtests/src/main/resources/preReg/UpdatePreregistration/updatePreregistrationResult.hbs +++ b/automationtests/src/main/resources/preReg/UpdatePreregistration/updatePreregistrationResult.hbs @@ -1,99 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "preRegistrationId": "$IGNORE$", - "updatedDateTime": "$IGNORE$", "statusCode": "Application_Incomplete", - "langCode": "$IGNORE$", "demographicDetails": { "identity": { - "gender": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "city": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "postalCode": "$IGNORE$", - "fullName": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "dateOfBirth": "$IGNORE$", - "IDSchemaVersion": "$IGNORE$", - "province": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "zone": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "phone": "$IGNORE$", - "addressLine1": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "residenceStatus": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "region": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "email": "$IGNORE$" + } } } diff --git a/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs b/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs index 8088c2c70ac..e9916f7c67c 100644 --- a/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs +++ b/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "message": "{{message}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml index 9cf29a2ec83..afbdbc8a1bd 100644 --- a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml +++ b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml @@ -99,8 +99,8 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_015", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_015" + } ] }' @@ -363,8 +363,8 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_031", - "message": "$IGNORE$" + "errorCode": "PRG_BOOK_RCI_031" + } ] }' @@ -555,8 +555,8 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_015", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_015" + } ] }' @@ -628,8 +628,8 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_013", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_013" + } ] }' diff --git a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs index b5d59189085..aac4a1fba68 100644 --- a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs @@ -1,9 +1,6 @@ { - "id": "mosip.pre-registration.booking.book", - "version": "1.0", - "responsetime": "$IGNORE$", + "response": { "bookingMessage": "Appointment booked successfully" - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml index 1b980f7d238..4a763528275 100644 --- a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml +++ b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml @@ -349,8 +349,8 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_031", - "message": "$IGNORE$" + "errorCode": "PRG_BOOK_RCI_031" + } ] }' @@ -493,8 +493,8 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_015", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_015" + } ] }' diff --git a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs index cc4f3a0d043..9fb6fa8707e 100644 --- a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs @@ -1,7 +1,4 @@ { - "id": "mosip.pre-registration.booking.book", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { "bookingStatusResponse": [ { diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml index ccfea7de3cd..c2be19e4338 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml +++ b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml @@ -2,6 +2,7 @@ CreatePrereg: Prereg_CreatePrereg_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -17,11 +18,11 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ - "langCode": "$1STLANG$" }' Prereg_CreatePrereg_All_Valid_Smoke_UpdateDocRefID_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -37,11 +38,11 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ - "langCode": "$1STLANG$" }' Prereg_CreatePrereg_All_Valid_Smoke_BookByPRID_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -62,6 +63,7 @@ CreatePrereg: Prereg_CreatePrereg_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -77,11 +79,11 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ - "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Smoke_alldel_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -97,11 +99,11 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ - "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Smoke_CancellAppointment_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -117,11 +119,11 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ - "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Smoke_CancelApplicationsAppointment_sid: endPoint: /preregistration/v1/applications/prereg role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/createPrereg/createPrereg outputTemplate: preReg/createPrereg/createPreregResult @@ -137,7 +139,6 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ - "langCode": "$1STLANG$" }' Prereg_CreatePrereg_in_Valid_id_sid: endPoint: /preregistration/v1/applications/prereg @@ -309,8 +310,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_015", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_015" } ] }' diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs b/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs index 39a3a0d689d..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs +++ b/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs @@ -1,100 +1,2 @@ { - "id": "mosip.pre-registration.demographic.create", - "version": "1.0", - "responsetime": "$IGNORE$", - "response": { - "preRegistrationId": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "statusCode": "$IGNORE$", - "langCode": "$IGNORE$", - "demographicDetails": { - "identity": { - "IDSchemaVersion": "$IGNORE$", - "fullName": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "dateOfBirth": "$IGNORE$", - "gender": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "residenceStatus": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "addressLine1": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "region": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "province": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "city": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "zone": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "postalCode": "$IGNORE$", - "phone": "$IGNORE$", - "email": "$IGNORE$" - } - } - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/error.hbs b/automationtests/src/main/resources/preReg/error.hbs index 9940609fdd9..f4bcb6bee67 100644 --- a/automationtests/src/main/resources/preReg/error.hbs +++ b/automationtests/src/main/resources/preReg/error.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "timestamp": "$IGNORE$", - "status": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "message": "{{message}}" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/preReg/uploadDocument/uploadDocument.yml b/automationtests/src/main/resources/preReg/uploadDocument/uploadDocument.yml index a249aadc234..482a7046b6a 100644 --- a/automationtests/src/main/resources/preReg/uploadDocument/uploadDocument.yml +++ b/automationtests/src/main/resources/preReg/uploadDocument/uploadDocument.yml @@ -662,8 +662,7 @@ UploadDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_017", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_017" } ] }' @@ -686,9 +685,8 @@ UploadDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_017", - "message": "$IGNORE$" - } + "errorCode": "PRG_CORE_REQ_017" + ] }' Prereg_UploadDocument_missing_docTypCode_sid: @@ -710,8 +708,7 @@ UploadDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_017", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_017" } ] }' @@ -734,8 +731,7 @@ UploadDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_018", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_018" } ] }' @@ -758,8 +754,7 @@ UploadDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_018", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_018" } ] }' @@ -782,8 +777,7 @@ UploadDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_018", - "message": "$IGNORE$" + "errorCode": "PRG_CORE_REQ_018" } ] }' diff --git a/automationtests/src/main/resources/preReg/uploadDocument/uploadDocumentResult.hbs b/automationtests/src/main/resources/preReg/uploadDocument/uploadDocumentResult.hbs index d729a7482af..9f6fc5e082b 100644 --- a/automationtests/src/main/resources/preReg/uploadDocument/uploadDocumentResult.hbs +++ b/automationtests/src/main/resources/preReg/uploadDocument/uploadDocumentResult.hbs @@ -1,14 +1,8 @@ { -"id":"{{id}}", -"version":"1.0", -"responsetime":"$IGNORE$", "response":{ - "preRegistrationId":"$IGNORE$", - "docId":"$IGNORE$", "docName":"{{docName}}", "docCatCode":"{{docCatCode}}", "docTypCode":"{{docTypCode}}", "docFileFormat":"{{docFileFormat}}" - }, -"errors":"$IGNORE$" + } } \ No newline at end of file From f0d2352787df3b6f6e4ed87072673323dcd72b57 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Fri, 25 Aug 2023 15:35:36 +0530 Subject: [PATCH 071/204] MOSIP-29084 --- .../ida/AuthInternalLock/AuthInternalLock.yml | 15 +- .../src/main/resources/ida/BioAuth/error.hbs | 14 +- .../main/resources/ida/DemoAuth/DemoAuth.yml | 201 +++--------------- .../main/resources/ida/EkycBio/EkycBio.yml | 101 ++------- .../ida/MultiFactorAuth/MultiFactorAuth.yml | 179 +--------------- .../ida/MultiFactorAuth/sendOtpRes.hbs | 3 - .../main/resources/ida/OtpAuth/OtpAuth.yml | 197 +++++++---------- .../ida/RevokeVID/createRevokeVIDResult.hbs | 6 +- .../ida/SendOTP/createSendOTPResult.hbs | 3 +- 9 files changed, 135 insertions(+), 584 deletions(-) diff --git a/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml b/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml index 2cf3b769d46..ce13c40047f 100644 --- a/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml +++ b/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml @@ -14,6 +14,7 @@ AuthInternalLock: "unlockForSeconds": 500 }' output: '{ + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Lock_UIN_Unlock_DemoAuth_Smoke_Pos: @@ -31,7 +32,7 @@ AuthInternalLock: "unlockForSeconds": 500 }' output: '{ - "responsetime": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Permanent_Lock_BioAuth_Smoke_Pos: @@ -49,7 +50,7 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "responsetime": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Permanent_Lock_DemoAuth_Smoke_Pos: @@ -67,7 +68,7 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "responsetime": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Lock_UIN_Unlock_WithSecs_BioAuth_Smoke_Pos: @@ -85,7 +86,7 @@ AuthInternalLock: "unlockForSeconds": 5 }' output: '{ - "responsetime": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Lock_UIN_Unlock_WithSecs_DemoAuth_Smoke_Pos: @@ -103,7 +104,7 @@ AuthInternalLock: "unlockForSeconds": 5 }' output: '{ - "responsetime": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Permanent_Lock_BioAuth_Valid_Smoke_Pos: @@ -121,7 +122,7 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "message": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' auth_AuthInternal_Permanent_Lock_DemoAuth_Valid_Smoke_Pos: @@ -139,5 +140,5 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "message": "$IGNORE$" + "message": "Notification has been sent to the provided contact detail(s)" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuth/error.hbs b/automationtests/src/main/resources/ida/BioAuth/error.hbs index c847b0ba8fc..14726464f22 100644 --- a/automationtests/src/main/resources/ida/BioAuth/error.hbs +++ b/automationtests/src/main/resources/ida/BioAuth/error.hbs @@ -1,22 +1,14 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { "body": { - "transactionID": "$IGNORE$", - "version": "$IGNORE$", - "id": "$IGNORE$", - "errors": [ + "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}", - "actionMessage": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} - ], - "responseTime": "$IGNORE$", + ] "response": { "authStatus": {{authStatus}} } diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index a324d4eefcd..5eb66166caf 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -12,13 +12,7 @@ DemoAuthNew: "key": "dob" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-019", - "errorMessage": "demo Auth Type is Locked for the UIN" - } - ], - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_DOB_Valid_Smoke_VID_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -49,12 +43,7 @@ DemoAuthNew: "key": "dob" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-001" - } - ] - "authStatus": "false" + "authStatus": "false" }' auth_DemoAuth_DOB_Invalid_Future_Timestamp_VID_Neg: @@ -70,12 +59,7 @@ DemoAuthNew: "key": "dob" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-001" - } - ] - "authStatus": "false" + "authStatus": "false" }' auth_DemoAuth_DOB_Empty_Timestamp_VID_Neg: @@ -91,12 +75,7 @@ DemoAuthNew: "key": "dob" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-001" - } - ] - "authStatus": "false" + "authStatus": "false" }' auth_DemoAuth_DOB_InValid_uin_Dateofbirth: @@ -112,12 +91,7 @@ DemoAuthNew: "key": "dob" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] + "authStatus": "false" }' auth_DemoAuth_DOB_InValid_Dateofbirth_with_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -132,12 +106,7 @@ DemoAuthNew: "key": "dob" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] + "authStatus": "false" }' auth_DemoAuth_Email_Valid_Smoke_Pos_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -168,12 +137,7 @@ DemoAuthNew: "key": "emailId" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-001" - } - ] - "authStatus": "false" + "authStatus": "false" }' auth_DemoAuth_Email_Invalid_Future_Timestamp_VID_Neg_VID: @@ -189,12 +153,7 @@ DemoAuthNew: "key": "emailId" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-001" - } - ] - "authStatus": "false" + "authStatus": "false" }' auth_DemoAuth_Email_Valid_Smoke_Poss_VID: @@ -225,12 +184,7 @@ DemoAuthNew: "key": "emailId" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-DEA-001" - } - ] + "authStatus": "false" }' auth_DemoAuth_Email_InValid_Email_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -245,12 +199,7 @@ DemoAuthNew: "key": "emailId" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-DEA-001" - } - ] + "authStatus": "false" }' auth_DemoAuth_gender_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -307,12 +256,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-DEA-001" - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_InValid_uin_gender: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -331,12 +275,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-DEA-001" - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_Name_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -526,13 +465,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-DEA-001", - "actionMessage": "Please re-enter your name in eng" - } - ], - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_InValid_Name_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -551,13 +484,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-DEA-001", - "actionMessage": "Please re-enter your name in eng" - } - ], - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_age_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -602,13 +529,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data age did not match" - } - ] + "authStatus": "false" }' auth_DemoAuth_age_InValid_uin: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -623,13 +544,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-DEA-001", - "errorMessage": "Demographic data age did not match" - } - ] + "authStatus": "false" }' auth_DemoAuth_PhoneNumber_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -659,13 +574,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-DEA-001", - "actionMessage": "Please re-enter your phoneNumber" - } - ], - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_PhoneNumber_InValid_PhoneNumber_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -680,13 +589,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-DEA-001", - "actionMessage": "Please re-enter your phoneNumber" - } - ], - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_PhoneNumber__with_Valid_TVID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Temp_VID_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -716,12 +619,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_DOB_Missing_individualId: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -736,12 +634,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_DOB_Blank_individualId: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -756,12 +649,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_DOB_Invalid_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123453636372829267890&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -806,12 +694,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-019", - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_DOB_Lock_Permanent_Valid_UIN_Neg: @@ -827,12 +710,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-019", - } - ] - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_revoke_vid_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_to_revoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -847,12 +725,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "authStatus": "false", - "errors": [ - { - "errorCode": "IDA-MLC-018" - } - ] + "authStatus": "false" }' auth_DemoAuth_dummy_partnerkey_uin_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Lock_permanent_DemoAuth_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -867,16 +740,7 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-007", - } - { - "errorCode": "IDA-MPA-009", - "errorMessage": "Partner is not registered" - } - ], - "authStatus": false + "authStatus": "false" }' auth_DemoAuth_DOB_Unlock_AllValid_UIN_Neg: @@ -892,14 +756,8 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-019", - } - ] - "authStatus": false + "authStatus": "false" }' - auth_DemoAuth_DOB_Lock_Permanent_AllValid_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Lock_permanent_DemoAuth_withValidParams_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident @@ -913,10 +771,5 @@ DemoAuthNew: "transactionId": "$TRANSACTIONID$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-019", - } - ] - "authStatus": false + "authStatus": "false" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml index 6ba711f9db4..b14c1b0dfec 100644 --- a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml +++ b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml @@ -865,12 +865,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-018" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_invalid_uin_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -898,12 +893,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_invalid_bioSubType_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -931,12 +921,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009" -} - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_blank_uin_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -964,12 +949,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_blank_bioSubType_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -997,12 +977,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Blank_uin_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1030,12 +1005,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Blank_bioType_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1063,12 +1033,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Invalid_uin_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1096,12 +1061,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Invalid_bioType_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1129,12 +1089,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Iris_With_FaceBio_uin_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1162,12 +1117,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Iris_With_FaceBio_Invalid_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1195,12 +1145,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Finger_With_FaceBio_uin_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1228,12 +1173,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Finger_With_FaceBio_Invalid_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1261,12 +1201,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] - "kycStatus": false + "kycStatus": "false" }' auth_EkycBio_Finger_With_dummy_partnerkey_Pos_vid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -1294,13 +1229,5 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-007" - }, - { - "errorCode": "IDA-MPA-009", - } - ] - "kycStatus": false + "kycStatus": "false" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml index 69a981cb2ef..d11c15df219 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml @@ -66,9 +66,9 @@ MultiFactorAuth: "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": true, + "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_Missing_transactionId_uin_Neg: @@ -102,9 +102,9 @@ MultiFactorAuth: "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": true, + "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' auth_MultiFactorAuth_Biometric_Face_With_Valid_vid_Smoke_Pos: @@ -175,12 +175,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-018", - "errorMessage": "VID not available in database" - } - ], "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -577,7 +571,6 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -614,7 +607,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -651,7 +643,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - " "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -688,7 +679,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -725,7 +715,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -762,7 +751,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -799,7 +787,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -836,7 +823,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -873,7 +859,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -910,7 +895,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - " "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -947,7 +931,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -984,7 +967,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1021,7 +1003,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1058,7 +1039,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1095,7 +1075,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1132,7 +1111,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1169,7 +1147,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1206,7 +1183,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1243,7 +1219,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1280,7 +1255,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1317,7 +1291,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1354,7 +1327,6 @@ MultiFactorAuth: output: '{ "authStatus": "true", "sendOtpResp":{ - "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } }' @@ -1391,7 +1363,6 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1428,7 +1399,6 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1465,7 +1435,6 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1502,7 +1471,6 @@ MultiFactorAuth: output: '{ "authStatus": false, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1539,7 +1507,6 @@ MultiFactorAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1576,7 +1543,6 @@ MultiFactorAuth: output: '{ "authStatus": true, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1612,11 +1578,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -1653,13 +1614,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1695,13 +1650,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1737,13 +1686,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1779,14 +1722,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-006", - - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1822,13 +1758,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1863,10 +1793,8 @@ MultiFactorAuth: "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": "$IGNORE$", - "errors": "$IGNORE$", + "authStatus": false, "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1902,13 +1830,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-006" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1944,13 +1866,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ], "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -1986,13 +1902,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -2028,14 +1938,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-007" - } - { - "errorCode": "IDA-DPM-004" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2072,14 +1974,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-007" - } - { - "errorCode": "IDA-DPM-004" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2116,11 +2010,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2157,13 +2046,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -2199,11 +2082,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2240,14 +2118,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-BIA-001", - "errorMessage": "$IGNORE$ - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -2283,13 +2154,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -2325,11 +2190,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-BIA-001" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2366,11 +2226,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2407,13 +2262,7 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ] "sendOtpResp":{ - "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -2449,11 +2298,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-011", - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2490,11 +2334,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-011" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -2531,14 +2370,6 @@ MultiFactorAuth: }' output: '{ "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-007" - }, - { - "errorCode": "IDA-MPA-009" - } - ] "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs b/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs index 8703038601e..8b580d5bd97 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/sendOtpRes.hbs @@ -1,9 +1,6 @@ { "id": "mosip.identity.otp", "version": "1.0", - "transactionID": "{{transactionID}}", "response": { - "maskedMobile": "{{maskedMobile}}", - "maskedEmail": "{{maskedEmail}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml index fe126f671f2..bcb4ca46cc6 100644 --- a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml @@ -9,8 +9,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "true", @@ -29,8 +29,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "true", @@ -49,8 +49,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "false", @@ -69,8 +69,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "false", @@ -89,8 +89,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "false", @@ -109,8 +109,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "false", @@ -129,8 +129,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "false", @@ -149,8 +149,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "false", @@ -168,16 +168,11 @@ OtpAuth: outputTemplate: ida/OtpAuth/error input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", - "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-018" - } - ] "authStatus": "false", "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" @@ -192,18 +187,13 @@ OtpAuth: outputTemplate: ida/OtpAuth/error input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", - "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -217,17 +207,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -241,17 +226,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -265,17 +245,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -289,17 +264,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ], - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -313,17 +283,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-009" - } - ] - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -337,12 +302,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "76544ddffgg@@@3444", - "timestamp": "$TIMESTAMP$" + "transactionID": "76544ddffgg@@@3444", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -356,12 +321,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "76544ddffgg@@@3444", - "timestamp": "$TIMESTAMP$" + "transactionID": "76544ddffgg@@@3444", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -375,12 +340,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "", - "timestamp": "$TIMESTAMP$" + "transactionID": "", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -394,13 +359,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "", - "timestamp": "$TIMESTAMP$" + "transactionID": "", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "sendOtpResp":{ - + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -414,13 +378,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", - "transactionID": "1234567892", - "timestamp": "$TIMESTAMP$" + "transactionID": "1234567892", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "sendOtpResp":{ - + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -434,12 +397,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": true, - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' @@ -453,8 +416,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": true, @@ -472,8 +435,8 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ "authStatus": "true", @@ -491,20 +454,12 @@ OtpAuth: input: '{ "otp": "$ID:AddIdentity_withValidParameters_smoke_Pos_EMAIL$", "individualId": "$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$", - "transactionID": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": false, - "errors": [ - { - "errorCode": "IDA-MLC-007" - }, - { - "errorCode": "IDA-MPA-009" - } - ] - "sendOtpResp":{ + "authStatus": "false", + "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs b/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs index bafa2f82a1c..08de5cbd505 100644 --- a/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs +++ b/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs index 763f9934fe8..345a4a7a017 100644 --- a/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs @@ -1,6 +1,5 @@ { "response": { - "maskedMobile": "{{maskedMobile}}", - "maskedEmail": "{{maskedEmail}}" + "maskedMobile": "{{maskedMobile}}" } } \ No newline at end of file From ff09bde41bb8832c7a4d42ed6a66ab4ab698002e Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 25 Aug 2023 19:12:05 +0530 Subject: [PATCH 072/204] MOSIP-29083 --- .../esignet/AddIdentity/addIdentityResult.hbs | 8 +- .../AuthenticateUser/AuthenticateUser.yml | 54 ++++++++ .../AuthenticateUserResult.hbs | 10 +- .../AuthorizationCode/AuthorizationCode.yml | 32 +++++ .../AuthorizationCodeResult.hbs | 13 +- .../AuthenticateUserConsentResult.hbs | 7 +- .../AuthorizationCodeConsent.yml | 4 + .../AuthorizationCodeConsentResult.hbs | 13 +- .../GenerateTokenConsentResult.hbs | 5 +- .../GetOidcUserInfoConsentResult.hbs | 9 +- .../OAuthDetailsRequestConsent.yml | 7 + .../OAuthDetailsRequestConsentResult.hbs | 17 +-- .../CreateOIDCClientResult.hbs | 6 +- .../esignet/GenerateApiKey/GenerateApiKey.yml | 1 + .../GenerateApiKey/GenerateApiKeyResult.hbs | 8 +- .../GenerateLinkCode/GenerateLinkCode.yml | 14 ++ .../GenerateLinkCodeResult.hbs | 12 +- .../GenerateToken/GenerateTokenResult.hbs | 5 +- .../GenerateVID/createGenerateVIDResult.hbs | 7 +- .../esignet/GetLinkStatus/GetLinkStatus.yml | 21 +++ .../GetLinkStatus/GetLinkStatusResult.hbs | 10 +- .../esignet/GetOidcClient/GetOidcClient.yml | 1 + .../GetOidcClient/GetOidcClientResult.hbs | 8 +- .../GetOidcUserInfo/GetOidcUserInfoResult.hbs | 9 +- .../esignet/KycBioAuth/KycBioAuthResult.hbs | 8 +- .../esignet/KycDemoAuth/KycDemoAuthResult.hbs | 8 +- .../LinkAuthorizationCode.yml | 16 +++ .../LinkAuthorizationCodeResult.hbs | 8 +- .../LinkTransaction/LinkTransaction.yml | 15 +++ .../LinkTransaction/LinkTransactionResult.hbs | 6 +- .../LinkedAuthenticationOtpResult.hbs | 8 +- .../LinkedAuthenticationWla.yml | 4 + .../LinkedAuthenticationWlaResult.hbs | 8 +- .../LinkedAuthorizationConsent.yml | 16 +++ .../LinkedAuthorizationConsentResult.hbs | 10 +- .../GenerateLinkCodeConsent.yml | 2 + .../GetLinkStatusConsent.yml | 2 + .../LinkAuthorizationCodeConsent.yml | 2 + .../LinkAuthorizationConsent.yml | 2 + .../LinkTransactionConsent.yml | 2 + .../LinkedAuthenticationConsentWla.yml | 2 + .../LinkedAuthenticationConsentWlaResult.hbs | 7 +- .../OAuthDetailsRequestLinkedConsent.yml | 2 + .../LinkedSendOtp/LinkedSendOtpResult.hbs | 7 +- .../LinkedValidateBindingResult.hbs | 8 +- .../OAuthDetailsRequest.yml | 123 ++++++++++++++++-- .../OAuthDetailsRequestNonAuth.yml | 26 ++++ .../OAuthDetailsRequestResult.hbs | 17 +-- .../OAuthDetailsRequest.yml | 5 + .../esignet/OidcClient/OIDCClient.yml | 15 +-- .../esignet/OidcClient/OIDCClientResult.hbs | 6 +- .../ApproveAPIKey/approveAPIKeyResult.hbs | 7 +- .../CreatePartner/createPartnerResult.hbs | 7 +- .../DeactivatePolicy/DeactivatePolicy.yml | 3 +- .../DeactivatePolicyResult.hbs | 9 -- .../DefinePolicy/definePolicyResult.hbs | 12 +- .../definePolicyGroupResult.hbs | 14 +- .../GenerateMispLK/GenerateMispLK.yml | 3 + .../GenerateMispLK/GenerateMispLKResult.hbs | 14 +- .../PublishPolicy/PublishPolicy.yml | 62 ++++----- .../PublishPolicy/publishPolicyResult.hbs | 28 +--- .../RequestAPIKey/requestAPIKeyResult.hbs | 8 +- .../UpdatePolicy/UpdatePolicy.yml | 3 +- .../UpdatePolicy/UpdatePolicyResult.hbs | 18 --- .../PmsIntegration/UploadCert/UploadCert.yml | 8 ++ .../UploadCert/uploadCertResult.hbs | 13 +- .../uploadCertificateResult.hbs | 10 +- .../esignet/SendBindingOtp/SendBindingOtp.yml | 20 +-- .../SendBindingOtp/SendBindingOtpResult.hbs | 7 +- .../esignet/SendOtp/SendOtpResult.hbs | 7 +- .../esignet/UpdateOIDC/UpdateOIDC.yml | 3 +- .../esignet/UpdateOIDC/UpdateOIDCResult.hbs | 6 +- .../UpdateOIDCClientResult.hbs | 6 +- .../esignet/WalletBinding/WalletBinding.yml | 98 ++++++++++---- .../WalletBinding/WalletBindingResult.hbs | 10 +- .../src/main/resources/esignet/error.hbs | 3 +- 76 files changed, 527 insertions(+), 468 deletions(-) delete mode 100644 automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicyResult.hbs delete mode 100644 automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicyResult.hbs diff --git a/automationtests/src/main/resources/esignet/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/esignet/AddIdentity/addIdentityResult.hbs index 720254c65ba..ca45b742b9e 100644 --- a/automationtests/src/main/resources/esignet/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/esignet/AddIdentity/addIdentityResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.id.create", - "version": "v1", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": [ - - ] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUser.yml b/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUser.yml index 0d14c0e8089..2ae6c03a395 100644 --- a/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUser.yml +++ b/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUser.yml @@ -3,6 +3,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/AuthenticateUser/AuthenticateUserResult @@ -35,6 +36,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/AuthenticateUser/AuthenticateUserResult @@ -67,6 +69,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/v2/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsent outputTemplate: esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsentResult @@ -100,6 +103,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/AuthenticateUser/AuthenticateUserResult @@ -132,6 +136,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/AuthenticateUser/AuthenticateUserResult @@ -164,6 +169,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/v2/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsent outputTemplate: esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsentResult @@ -197,6 +203,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -235,6 +242,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -273,6 +281,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -311,6 +320,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -349,6 +359,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -387,6 +398,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -425,6 +437,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -463,6 +476,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -501,6 +515,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -539,6 +554,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -577,6 +593,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -615,6 +632,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -653,6 +671,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -691,6 +710,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -729,6 +749,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -767,6 +788,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -805,6 +827,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -843,6 +866,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -881,6 +905,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -919,6 +944,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -957,6 +983,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -995,6 +1022,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1033,6 +1061,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1071,6 +1100,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1109,6 +1139,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/AuthenticateUser/AuthenticateUserResult @@ -1141,6 +1172,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1179,6 +1211,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1217,6 +1250,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1255,6 +1289,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1293,6 +1328,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1331,6 +1367,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1369,6 +1406,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1407,6 +1445,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1445,6 +1484,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1483,6 +1523,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1521,6 +1562,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1559,6 +1601,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1597,6 +1640,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1635,6 +1679,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1673,6 +1718,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1711,6 +1757,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1749,6 +1796,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1787,6 +1835,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1825,6 +1874,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1863,6 +1913,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1901,6 +1952,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1939,6 +1991,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error @@ -1977,6 +2030,7 @@ AuthenticateUser: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthenticateUser/AuthenticateUser outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUserResult.hbs b/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUserResult.hbs index 527383e0906..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUserResult.hbs +++ b/automationtests/src/main/resources/esignet/AuthenticateUser/AuthenticateUserResult.hbs @@ -1,9 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCode.yml b/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCode.yml index 15f4b08a338..5117bdcede5 100644 --- a/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCode.yml +++ b/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCode.yml @@ -3,6 +3,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/AuthorizationCode/AuthorizationCodeResult @@ -20,6 +21,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -42,6 +44,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -64,6 +67,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -86,6 +90,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -108,6 +113,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -130,6 +136,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -153,6 +160,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -176,6 +184,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -199,6 +208,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -221,6 +231,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/AuthorizationCode/AuthorizationCodeResult @@ -238,6 +249,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -260,6 +272,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -282,6 +295,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -304,6 +318,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -326,6 +341,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -348,6 +364,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/AuthorizationCode/AuthorizationCodeResult @@ -365,6 +382,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -387,6 +405,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -409,6 +428,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -431,6 +451,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -453,6 +474,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -475,6 +497,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -498,6 +521,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -521,6 +545,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -544,6 +569,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -566,6 +592,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/AuthorizationCode/AuthorizationCodeResult @@ -583,6 +610,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -605,6 +633,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -627,6 +656,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -649,6 +679,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error @@ -671,6 +702,7 @@ AuthorizationCode: endPoint: /v1/esignet/authorization/auth-code role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/AuthorizationCode/AuthorizationCode outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCodeResult.hbs b/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCodeResult.hbs index d4d6200a1e6..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCodeResult.hbs +++ b/automationtests/src/main/resources/esignet/AuthorizationCode/AuthorizationCodeResult.hbs @@ -1,12 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "nonce": "$IGNORE$", - "code": "$IGNORE$", - "state": "$IGNORE$", - "redirectUri": "{{redirectUri}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsentResult.hbs b/automationtests/src/main/resources/esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsentResult.hbs index 3ddaf269863..72fa0607d7e 100644 --- a/automationtests/src/main/resources/esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsentResult.hbs +++ b/automationtests/src/main/resources/esignet/Consent/AuthenticateUserConsent/AuthenticateUserConsentResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "consentAction": "{{consentAction}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent.yml b/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent.yml index 760ae0363bb..a9e70c9873d 100644 --- a/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent.yml +++ b/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent.yml @@ -2,6 +2,7 @@ AuthorizationCodeConsent: ESignet_AuthorizationCode_Consent_uin_Claim2_All_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent @@ -19,6 +20,7 @@ AuthorizationCodeConsent: ESignet_AuthorizationCode_Consent_Vid_Claim2_All_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent @@ -36,6 +38,7 @@ AuthorizationCodeConsent: ESignet_AuthorizationCode_Consent_uin_All_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent @@ -53,6 +56,7 @@ AuthorizationCodeConsent: ESignet_AuthorizationCode_Consent_Vid_All_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsent diff --git a/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsentResult.hbs b/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsentResult.hbs index d4d6200a1e6..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsentResult.hbs +++ b/automationtests/src/main/resources/esignet/Consent/AuthorizationCodeConsent/AuthorizationCodeConsentResult.hbs @@ -1,12 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "nonce": "$IGNORE$", - "code": "$IGNORE$", - "state": "$IGNORE$", - "redirectUri": "{{redirectUri}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/Consent/GenerateTokenConsent/GenerateTokenConsentResult.hbs b/automationtests/src/main/resources/esignet/Consent/GenerateTokenConsent/GenerateTokenConsentResult.hbs index c61b3a64f21..c323e20a77e 100644 --- a/automationtests/src/main/resources/esignet/Consent/GenerateTokenConsent/GenerateTokenConsentResult.hbs +++ b/automationtests/src/main/resources/esignet/Consent/GenerateTokenConsent/GenerateTokenConsentResult.hbs @@ -1,6 +1,3 @@ { - "id_token": "$IGNORE$", - "access_token": "$IGNORE$", - "token_type": "{{token_type}}", - "expires_in": "$IGNORE$" + "token_type": "{{token_type}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/Consent/GetOidcUserInfoConsent/GetOidcUserInfoConsentResult.hbs b/automationtests/src/main/resources/esignet/Consent/GetOidcUserInfoConsent/GetOidcUserInfoConsentResult.hbs index 39bc4c8b48c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/Consent/GetOidcUserInfoConsent/GetOidcUserInfoConsentResult.hbs +++ b/automationtests/src/main/resources/esignet/Consent/GetOidcUserInfoConsent/GetOidcUserInfoConsentResult.hbs @@ -1,8 +1 @@ -{ - "id": null, - "version": null, - "responseTime": "$IGNORE$", - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent.yml b/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent.yml index 5050a3775b2..57c4a48cfbd 100644 --- a/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent.yml +++ b/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent.yml @@ -2,6 +2,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult @@ -25,6 +26,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_Claim2_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentNewClaim outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult @@ -48,6 +50,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_Invalid_Scen_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult @@ -71,6 +74,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult @@ -94,6 +98,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_Vid_Claim2_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentNewClaim outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult @@ -117,6 +122,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_User2_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult @@ -140,6 +146,7 @@ OAuthDetailsRequestConsent: ESignet_OAuthDetailsRequest_Consent_Vid_User2_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult diff --git a/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult.hbs b/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult.hbs index 3a0c7968ea6..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult.hbs +++ b/automationtests/src/main/resources/esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult.hbs @@ -1,16 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$", - "clientName": "$IGNORE$", - "logoUrl": "$IGNORE$", - "authFactors": "$IGNORE$", - "authorizeScopes": "$IGNORE$", - "essentialClaims": "$IGNORE$", - "voluntaryClaims": "$IGNORE$", - "configs": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/CreateOIDCClient/CreateOIDCClientResult.hbs b/automationtests/src/main/resources/esignet/CreateOIDCClient/CreateOIDCClientResult.hbs index da9ba5fbf4e..ad005e7c3f5 100644 --- a/automationtests/src/main/resources/esignet/CreateOIDCClient/CreateOIDCClientResult.hbs +++ b/automationtests/src/main/resources/esignet/CreateOIDCClient/CreateOIDCClientResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { "clientId": "{{clientId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKey.yml b/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKey.yml index 5c01ea4c267..69065dc2190 100644 --- a/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKey.yml +++ b/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKey.yml @@ -2,6 +2,7 @@ GenerateApiKey: ESignet_GenerateApiKey_Valid_Smoke_sid: endPoint: /v1/partnermanager/partners/$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$/generate/apikey role: esignetpartner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: esignet/GenerateApiKey/GenerateApiKey outputTemplate: esignet/GenerateApiKey/GenerateApiKeyResult diff --git a/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKeyResult.hbs b/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKeyResult.hbs index 0fa330253bc..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKeyResult.hbs +++ b/automationtests/src/main/resources/esignet/GenerateApiKey/GenerateApiKeyResult.hbs @@ -1,7 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCode.yml b/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCode.yml index 4225d757f43..24a5259a022 100644 --- a/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCode.yml +++ b/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCode.yml @@ -2,6 +2,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/GenerateLinkCode/GenerateLinkCodeResult @@ -16,6 +17,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/GenerateLinkCode/GenerateLinkCodeResult @@ -30,6 +32,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Consent_uin_SameClaim_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode @@ -45,6 +48,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Consent_Vid_SameClaim_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode @@ -60,6 +64,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Invalid_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -79,6 +84,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Past_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -98,6 +104,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Future_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -117,6 +124,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Missing_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -136,6 +144,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Space_As_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -155,6 +164,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Invalid_transactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -174,6 +184,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Expired_transactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -193,6 +204,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Missing_transactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -212,6 +224,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Empty_transactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error @@ -231,6 +244,7 @@ GenerateLinkCode: ESignet_GenerateLinkCode_Null_transactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCodeResult.hbs b/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCodeResult.hbs index f380d51cd95..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCodeResult.hbs +++ b/automationtests/src/main/resources/esignet/GenerateLinkCode/GenerateLinkCodeResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$", - "linkCode": "$IGNORE$", - "expireDateTime": "$IGNORE$" - }, - "errors": "$IGNORE$" - } \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GenerateToken/GenerateTokenResult.hbs b/automationtests/src/main/resources/esignet/GenerateToken/GenerateTokenResult.hbs index c61b3a64f21..c323e20a77e 100644 --- a/automationtests/src/main/resources/esignet/GenerateToken/GenerateTokenResult.hbs +++ b/automationtests/src/main/resources/esignet/GenerateToken/GenerateTokenResult.hbs @@ -1,6 +1,3 @@ { - "id_token": "$IGNORE$", - "access_token": "$IGNORE$", - "token_type": "{{token_type}}", - "expires_in": "$IGNORE$" + "token_type": "{{token_type}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVIDResult.hbs index 97c855c020c..08de5cbd505 100644 --- a/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVIDResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.vid", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "vid": "{{vid}}", "message": "{{message}}" - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatus.yml b/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatus.yml index e231aafb53e..e3c0292b7b9 100644 --- a/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatus.yml +++ b/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatus.yml @@ -2,6 +2,7 @@ GetLinkStatus: ESignet_GetLinkStatus_all_Valid_Smoke: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/GetLinkStatus/GetLinkStatusResult @@ -17,6 +18,7 @@ GetLinkStatus: ESignet_GetLinkStatus_vid_all_Valid_Smoke: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/GetLinkStatus/GetLinkStatusResult @@ -32,6 +34,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Consent_uin_SameClaim_all_Valid_Smoke: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GetLinkStatus/GetLinkStatus @@ -48,6 +51,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Consent_Vid_SameClaim_all_Valid_Smoke: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GetLinkStatus/GetLinkStatus @@ -64,6 +68,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Invalid_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -84,6 +89,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Past_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -104,6 +110,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Future_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -124,6 +131,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Missing_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -144,6 +152,7 @@ GetLinkStatus: ESignet_GetLinkStatus_SpaceVal_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -164,6 +173,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Invalid_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -184,6 +194,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Expired_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -204,6 +215,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Empty_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -224,6 +236,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Missing_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -244,6 +257,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Null_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -264,6 +278,7 @@ GetLinkStatus: ESignet_GetLinkStatus_SpaceVal_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -284,6 +299,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Invalid_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -304,6 +320,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Expired_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -324,6 +341,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Missing_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -344,6 +362,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Empty_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -364,6 +383,7 @@ GetLinkStatus: ESignet_GetLinkStatus_Null_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error @@ -384,6 +404,7 @@ GetLinkStatus: ESignet_GetLinkStatus_SpaceVal_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/GetLinkStatus/GetLinkStatus outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatusResult.hbs b/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatusResult.hbs index 414c211874b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatusResult.hbs +++ b/automationtests/src/main/resources/esignet/GetLinkStatus/GetLinkStatusResult.hbs @@ -1,9 +1 @@ -{ - "responseTIme": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$", - "linkStatus": "$IGNORE$", - "linkedDateTime": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClient.yml b/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClient.yml index 6ff509f2433..36060b52f3a 100644 --- a/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClient.yml +++ b/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClient.yml @@ -2,6 +2,7 @@ GetOidcClient: Esignet_GetOidcClient_all_Valid_Smoke: endPoint: /v1/partnermanager/oidc/client/{client_id} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: esignet/GetOidcClient/GetOidcClient outputTemplate: esignet/GetOidcClient/GetOidcClientResult diff --git a/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClientResult.hbs b/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClientResult.hbs index 703612bc540..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClientResult.hbs +++ b/automationtests/src/main/resources/esignet/GetOidcClient/GetOidcClientResult.hbs @@ -1,7 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GetOidcUserInfo/GetOidcUserInfoResult.hbs b/automationtests/src/main/resources/esignet/GetOidcUserInfo/GetOidcUserInfoResult.hbs index 39bc4c8b48c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/GetOidcUserInfo/GetOidcUserInfoResult.hbs +++ b/automationtests/src/main/resources/esignet/GetOidcUserInfo/GetOidcUserInfoResult.hbs @@ -1,8 +1 @@ -{ - "id": null, - "version": null, - "responseTime": "$IGNORE$", - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResult.hbs b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResult.hbs index 5700c2fea1e..827c6a86ec7 100644 --- a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResult.hbs +++ b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResult.hbs @@ -1,11 +1,5 @@ { - "transactionID": "$IGNORE$", - "version": "1.0", - "id": "mosip.identity.kycauth", - "errors": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "authStatus": {{authStatus}}, - "authToken": "$IGNORE$" + "authStatus": {{authStatus}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/KycDemoAuth/KycDemoAuthResult.hbs b/automationtests/src/main/resources/esignet/KycDemoAuth/KycDemoAuthResult.hbs index 5700c2fea1e..827c6a86ec7 100644 --- a/automationtests/src/main/resources/esignet/KycDemoAuth/KycDemoAuthResult.hbs +++ b/automationtests/src/main/resources/esignet/KycDemoAuth/KycDemoAuthResult.hbs @@ -1,11 +1,5 @@ { - "transactionID": "$IGNORE$", - "version": "1.0", - "id": "mosip.identity.kycauth", - "errors": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "authStatus": {{authStatus}}, - "authToken": "$IGNORE$" + "authStatus": {{authStatus}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCode.yml b/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCode.yml index b8b74ab9144..18ba50175c3 100644 --- a/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCode.yml +++ b/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCode.yml @@ -2,6 +2,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Consent_uin_SameClaim_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode @@ -18,6 +19,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCodeResult @@ -33,6 +35,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCodeResult @@ -48,6 +51,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Invalid_requestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -68,6 +72,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Past_Val_requestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -88,6 +93,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Future_Val_requestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -108,6 +114,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Empty_Val_requestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -128,6 +135,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Space_Val_requestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -148,6 +156,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Invalid_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -168,6 +177,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Space_Val_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -188,6 +198,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Missing_Val_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -208,6 +219,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Empty_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -228,6 +240,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Invalid_linkedCode_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -248,6 +261,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Misssing_linkedCode_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -268,6 +282,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Space_Val_linkedCode_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error @@ -288,6 +303,7 @@ LinkAuthorizationCode: ESignet_LinkAuthorizationCode_Empty_Val_linkedCode_Neg: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCodeResult.hbs b/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCodeResult.hbs index 3472003ca1c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCodeResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkAuthorizationCode/LinkAuthorizationCodeResult.hbs @@ -1,7 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": { - "linkTransactionId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransaction.yml b/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransaction.yml index 2b6cc3321d2..59d34733d69 100644 --- a/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransaction.yml +++ b/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransaction.yml @@ -2,6 +2,7 @@ LinkTransaction: ESignet_LinkTransaction_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/LinkTransaction/LinkTransactionResult @@ -16,6 +17,7 @@ LinkTransaction: ESignet_LinkTransaction_vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/LinkTransaction/LinkTransactionResult @@ -30,6 +32,7 @@ LinkTransaction: ESignet_LinkTransaction_Consent_uin_SameClaim_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkTransaction/LinkTransaction @@ -45,6 +48,7 @@ LinkTransaction: ESignet_LinkTransaction_Consent_Vid_SameClaim_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkTransaction/LinkTransaction @@ -60,6 +64,7 @@ LinkTransaction: ESignet_LinkTransaction_Invalid_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -80,6 +85,7 @@ LinkTransaction: ESignet_LinkTransaction_RequestTime_PastValue_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -100,6 +106,7 @@ LinkTransaction: ESignet_LinkTransaction_RequestTime_FutureValue_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -120,6 +127,7 @@ LinkTransaction: ESignet_Link_Transaction_Absent_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -140,6 +148,7 @@ LinkTransaction: ESignet_LinkTransaction_Space_Val_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -160,6 +169,7 @@ LinkTransaction: ESignet_LinkTransaction_Empty_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -180,6 +190,7 @@ LinkTransaction: ESignet_LinkTransaction_Invalid_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -200,6 +211,7 @@ LinkTransaction: ESignet_LinkTransaction_Missing_val_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -220,6 +232,7 @@ LinkTransaction: ESignet_LinkTransaction_Expired_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -240,6 +253,7 @@ LinkTransaction: ESignet_LinkTransaction_Empty_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error @@ -260,6 +274,7 @@ LinkTransaction: ESignet_LinkTransaction_Null_LinkCode_Neg: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkTransaction/LinkTransaction outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransactionResult.hbs b/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransactionResult.hbs index 6a97b7fabf4..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransactionResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkTransaction/LinkTransactionResult.hbs @@ -1,5 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedAuthenticationOtp/LinkedAuthenticationOtpResult.hbs b/automationtests/src/main/resources/esignet/LinkedAuthenticationOtp/LinkedAuthenticationOtpResult.hbs index 3472003ca1c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthenticationOtp/LinkedAuthenticationOtpResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkedAuthenticationOtp/LinkedAuthenticationOtpResult.hbs @@ -1,7 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": { - "linkTransactionId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml b/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml index bd39f91655c..d0793e82608 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml +++ b/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml @@ -2,6 +2,7 @@ LinkedAuthenticationWla: ESignet_LinkedAuthenticationWla_Consent_SameClaim_uin_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/v2/authenticate role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla @@ -52,6 +53,7 @@ LinkedAuthenticationWla: ESignet_LinkedAuthenticationWla_Consent_SameClaim_Vid_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/v2/authenticate role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla @@ -102,6 +104,7 @@ LinkedAuthenticationWla: ESignet_LinkedAuthenticationWla_uin_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/authenticate role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla @@ -151,6 +154,7 @@ LinkedAuthenticationWla: ESignet_LinkedAuthenticationWla_vid_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/authenticate role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla diff --git a/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWlaResult.hbs b/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWlaResult.hbs index 3472003ca1c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWlaResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWlaResult.hbs @@ -1,7 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": { - "linkTransactionId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml b/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml index b5be18219b4..c588234f00b 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml @@ -2,6 +2,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Consent_uin_SameClaim_Invalid_Neg: endPoint: /v1/esignet/linked-authorization/v2/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent @@ -23,6 +24,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_All_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult @@ -38,6 +40,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_vid_All_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult @@ -53,6 +56,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Invalid_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -72,6 +76,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Past_Val_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -91,6 +96,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Future_Val_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -110,6 +116,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Space_Val_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -129,6 +136,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Empty_Val_RequestTime_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -148,6 +156,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Invalid_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -167,6 +176,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Missing_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -186,6 +196,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Empty_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -205,6 +216,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Space_Val_TransactionId_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -224,6 +236,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Invalid_AcceptedClaims_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -244,6 +257,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Null_AcceptedClaims_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -264,6 +278,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Invalid_permittedAuthorizeScopes_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error @@ -285,6 +300,7 @@ LinkedAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Null_permittedAuthorizeScopes_Neg: endPoint: /v1/esignet/linked-authorization/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent outputTemplate: esignet/error diff --git a/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult.hbs b/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult.hbs index e8a5b1a74f5..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult.hbs @@ -1,9 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "linkedTransactionId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml index 66228135310..3351d66273b 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml @@ -2,6 +2,7 @@ GenerateLinkCodeConsent: ESignet_GenerateLinkCode_Consent_uin_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode @@ -17,6 +18,7 @@ GenerateLinkCodeConsent: ESignet_GenerateLinkCode_Consent_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml index fd84b371e1e..53f2b8deeef 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml @@ -2,6 +2,7 @@ GetLinkStatusConsent: ESignet_GetLinkStatus_Consent_uin_all_Valid_Smoke: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GetLinkStatus/GetLinkStatus @@ -18,6 +19,7 @@ GetLinkStatusConsent: ESignet_GetLinkStatus_Consent_Vid_all_Valid_Smoke: endPoint: /v1/esignet/linked-authorization/link-status role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/GetLinkStatus/GetLinkStatus diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationCodeConsent/LinkAuthorizationCodeConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationCodeConsent/LinkAuthorizationCodeConsent.yml index 4ea73ad393a..a4793dfd4a5 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationCodeConsent/LinkAuthorizationCodeConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationCodeConsent/LinkAuthorizationCodeConsent.yml @@ -2,6 +2,7 @@ LinkAuthorizationCodeConsent: ESignet_LinkAuthorizationCode_Consent_uin_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode @@ -18,6 +19,7 @@ LinkAuthorizationCodeConsent: ESignet_LinkAuthorizationCode_Consent_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-auth-code role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkAuthorizationCode/LinkAuthorizationCode diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml index b3117020fa7..17679402a2a 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml @@ -2,6 +2,7 @@ LinkAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Consent_uin_All_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/v2/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent @@ -18,6 +19,7 @@ LinkAuthorizationConsent: ESignet_LinkedAuthorizationConsent_Consent_Vid_All_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/v2/consent role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml index dc08d1841ab..73d347c6f17 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml @@ -2,6 +2,7 @@ LinkTransactionConsent: ESignet_LinkTransaction_Consent_uin_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkTransaction/LinkTransaction @@ -17,6 +18,7 @@ LinkTransactionConsent: ESignet_LinkTransaction_Consent_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/link-transaction role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkTransaction/LinkTransaction diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml index b3d80666b2e..7aaf42045ae 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml @@ -2,6 +2,7 @@ LinkedAuthenticationConsentWla: ESignet_LinkedAuthenticationWla_Consentuin_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/v2/authenticate role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla @@ -52,6 +53,7 @@ LinkedAuthenticationConsentWla: ESignet_LinkedAuthenticationWla_ConsentVid_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/v2/authenticate role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWlaResult.hbs b/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWlaResult.hbs index 3ddaf269863..72fa0607d7e 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWlaResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWlaResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "consentAction": "{{consentAction}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml index d4db74143ee..78866adf712 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml @@ -2,6 +2,7 @@ OAuthDetailsRequestLinkedConsent: ESignet_OAuthDetailsRequest_LinkAuth_Consent_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -25,6 +26,7 @@ OAuthDetailsRequestLinkedConsent: ESignet_OAuthDetailsRequest_LinkAuth_Consent_vid_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult diff --git a/automationtests/src/main/resources/esignet/LinkedSendOtp/LinkedSendOtpResult.hbs b/automationtests/src/main/resources/esignet/LinkedSendOtp/LinkedSendOtpResult.hbs index 15af7dc7dd6..c823777f1e9 100644 --- a/automationtests/src/main/resources/esignet/LinkedSendOtp/LinkedSendOtpResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkedSendOtp/LinkedSendOtpResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "maskedEmail": "{{maskedEmail}}", "maskedMobile": "{{maskedMobile}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedValidateBinding/LinkedValidateBindingResult.hbs b/automationtests/src/main/resources/esignet/LinkedValidateBinding/LinkedValidateBindingResult.hbs index 3472003ca1c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/LinkedValidateBinding/LinkedValidateBindingResult.hbs +++ b/automationtests/src/main/resources/esignet/LinkedValidateBinding/LinkedValidateBindingResult.hbs @@ -1,7 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": { - "linkTransactionId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequest.yml b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequest.yml index f6ff5b6f356..0aae05e846d 100644 --- a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequest.yml +++ b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequest.yml @@ -3,6 +3,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -26,6 +27,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -49,6 +51,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -72,6 +75,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult input: '{ @@ -95,6 +99,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -118,6 +123,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsent outputTemplate: esignet/Consent/OAuthDetailsRequestConsent/OAuthDetailsRequestConsentResult input: '{ @@ -141,6 +147,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -164,6 +171,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -187,6 +195,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -210,6 +219,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -232,6 +242,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -255,6 +266,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -278,6 +290,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -300,6 +313,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -322,6 +336,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -344,6 +359,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -366,6 +382,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -388,6 +405,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -410,6 +428,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -432,6 +451,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -454,6 +474,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -477,6 +498,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -500,6 +522,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -523,6 +546,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -546,6 +570,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -569,6 +594,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -592,6 +618,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -615,6 +642,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -638,6 +666,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -661,6 +690,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -684,6 +714,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -707,6 +738,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -730,6 +762,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -753,6 +786,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -776,6 +810,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -804,6 +839,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -832,6 +868,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -860,6 +897,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -888,6 +926,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -916,6 +955,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -944,6 +984,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -972,6 +1013,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1000,6 +1042,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1028,6 +1071,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1056,6 +1100,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1084,6 +1129,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1112,6 +1158,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1140,6 +1187,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1168,6 +1216,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1196,6 +1245,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1224,6 +1274,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1252,6 +1303,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1280,6 +1332,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1303,6 +1356,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1326,6 +1380,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1349,6 +1404,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1372,6 +1428,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1395,6 +1452,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1418,6 +1476,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestEmptyClaims outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1438,12 +1497,13 @@ OAuthDetailsRequest: }' - ESignet_OAuthDetailsRequest_Empty_Claims_Pos: + ESignet_OAuthDetailsRequest_Empty_Claims_Neg: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestEmptyClaims - outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult + outputTemplate: esignet/error input: '{ "requestTime": "$TIMESTAMP$", "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", @@ -1461,8 +1521,7 @@ OAuthDetailsRequest: output: '{ "errors": [ { - "errorCode": "unknown_error", - "errorMessage": "$IGNORE$" + "errorCode": "unknown_error" } ] }' @@ -1471,6 +1530,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestInvalidClaim outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1494,6 +1554,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1517,6 +1578,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1540,6 +1602,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1563,6 +1626,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1586,6 +1650,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1609,6 +1674,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1633,12 +1699,13 @@ OAuthDetailsRequest: ] }' - ESignet_OAuthDetailsRequest_Empty_display_Pos: + ESignet_OAuthDetailsRequest_Empty_display_Neg: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest - outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult + outputTemplate: esignet/error input: '{ "requestTime": "$TIMESTAMP$", "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", @@ -1653,13 +1720,18 @@ OAuthDetailsRequest: "claimsLocales": "en" }' output: '{ - + "errors": [ + { + "errorCode": "invalid_display" + } + ] }' ESignet_OAuthDetailsRequest_Null_display_Neg: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1684,12 +1756,13 @@ OAuthDetailsRequest: ] }' - ESignet_OAuthDetailsRequest_SpaceValue_display_Pos: + ESignet_OAuthDetailsRequest_SpaceValue_display_Neg: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest - outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult + outputTemplate: esignet/error input: '{ "requestTime": "$TIMESTAMP$", "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", @@ -1704,13 +1777,18 @@ OAuthDetailsRequest: "claimsLocales": "en" }' output: '{ - + "errors": [ + { + "errorCode": "invalid_display" + } + ] }' ESignet_OAuthDetailsRequest_Invalid_State_Pos: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1734,6 +1812,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1757,6 +1836,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1780,6 +1860,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1803,6 +1884,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1826,6 +1908,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1849,6 +1932,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1872,6 +1956,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1895,6 +1980,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -1918,6 +2004,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1946,6 +2033,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -1974,6 +2062,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -2002,6 +2091,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult input: '{ @@ -2020,12 +2110,13 @@ OAuthDetailsRequest: output: '{ }' - ESignet_OAuthDetailsRequest_Empty_Prompt_Pos: + ESignet_OAuthDetailsRequest_Empty_Prompt_Neg: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest - outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult + outputTemplate: esignet/error input: '{ "requestTime": "$TIMESTAMP$", "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", @@ -2040,13 +2131,18 @@ OAuthDetailsRequest: "claimsLocales": "en" }' output: '{ - + "errors": [ + { + "errorCode": "invalid_prompt" + } + ] }' ESignet_OAuthDetailsRequest_Null_Prompt_Neg: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ @@ -2075,6 +2171,7 @@ OAuthDetailsRequest: endPoint: /v1/esignet/authorization/oauth-details role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/error input: '{ diff --git a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNonAuth.yml b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNonAuth.yml index d641f114560..1e8ba2435f1 100644 --- a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNonAuth.yml +++ b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNonAuth.yml @@ -2,6 +2,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_Otp_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -25,6 +26,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_Otp_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -48,6 +50,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_BioFace_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -71,6 +74,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_BioFace_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -94,6 +98,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RingFinger_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -117,6 +122,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RingFinger_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -140,6 +146,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftMiddleFingerr_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -163,6 +170,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftMiddleFingerr_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -186,6 +194,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftLittleFinger_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -209,6 +218,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftLittleFinger_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -232,6 +242,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightIndexFinger_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -255,6 +266,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightIndexFinger_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -278,6 +290,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightRingFinger_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -301,6 +314,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightRingFinger_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -324,6 +338,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightMiddleFinger_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -347,6 +362,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightMiddleFinger_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -370,6 +386,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightLittleFinger_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -393,6 +410,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightLittleFinger_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -416,6 +434,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftThumb_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -439,6 +458,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftThumb_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -462,6 +482,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightThumb_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -485,6 +506,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightThumb_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -508,6 +530,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightIris_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -531,6 +554,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_RightIris_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -554,6 +578,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftIris_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -577,6 +602,7 @@ OAuthDetailsRequestNonAuth: ESignet_OAuthDetailsRequest_NonAuth_LeftIris_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult diff --git a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs index 3a0c7968ea6..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs +++ b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs @@ -1,16 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$", - "clientName": "$IGNORE$", - "logoUrl": "$IGNORE$", - "authFactors": "$IGNORE$", - "authorizeScopes": "$IGNORE$", - "essentialClaims": "$IGNORE$", - "voluntaryClaims": "$IGNORE$", - "configs": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/OAuthDetailsRequestLinked/OAuthDetailsRequest.yml b/automationtests/src/main/resources/esignet/OAuthDetailsRequestLinked/OAuthDetailsRequest.yml index ede0b203f23..4d1e63768df 100644 --- a/automationtests/src/main/resources/esignet/OAuthDetailsRequestLinked/OAuthDetailsRequest.yml +++ b/automationtests/src/main/resources/esignet/OAuthDetailsRequestLinked/OAuthDetailsRequest.yml @@ -2,6 +2,7 @@ OAuthDetailsRequestLinked: ESignet_OAuthDetailsRequest_LinkAuth_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -25,6 +26,7 @@ OAuthDetailsRequestLinked: ESignet_OAuthDetailsRequest_LinkAuth_Vid_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -48,6 +50,7 @@ OAuthDetailsRequestLinked: ESignet_OAuthDetailsRequest_LinkAuth_Consent_SameClaim_Uin_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -71,6 +74,7 @@ OAuthDetailsRequestLinked: ESignet_OAuthDetailsRequest_LinkAuth_Consent_SameClaim_Vid_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -94,6 +98,7 @@ OAuthDetailsRequestLinked: ESignet_OAuthDetailsRequest_LinkAuth_Other_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult diff --git a/automationtests/src/main/resources/esignet/OidcClient/OIDCClient.yml b/automationtests/src/main/resources/esignet/OidcClient/OIDCClient.yml index 1faaf5f533b..6a7cfa611a5 100644 --- a/automationtests/src/main/resources/esignet/OidcClient/OIDCClient.yml +++ b/automationtests/src/main/resources/esignet/OidcClient/OIDCClient.yml @@ -323,8 +323,7 @@ CreateOIDCClient: output: '{ "errors": [ { - "errorCode": "$IGNORE$", - "message": "Invalid request parameter - must be a valid URL :request.logoUri" + "errorCode": "invalid_redirect_uri" } ] }' @@ -347,8 +346,7 @@ CreateOIDCClient: output: '{ "errors": [ { - "errorCode": "$IGNORE$", - "message": "invalid_client_auth --> request.clientAuthMethods[0]: invalid_client_auth" + "errorCode": "invalid_client_auth" } ] }' @@ -371,8 +369,7 @@ CreateOIDCClient: output: '{ "errors": [ { - "errorCode": "$IGNORE$", - "message": "invalid_grant_type --> request.grantTypes[0]: invalid_grant_type" + "errorCode": "invalid_grant_type" } ] }' @@ -395,8 +392,7 @@ CreateOIDCClient: output: '{ "errors": [ { - "errorCode": "$IGNORE$", - "message": "invalid_grant_type --> request.grantTypes[0]: invalid_grant_type" + "errorCode": "invalid_grant_type" } ] }' @@ -419,8 +415,7 @@ CreateOIDCClient: output: '{ "errors": [ { - "errorCode": $IGNORE$, - "message": "invalid_grant_type --> request.grantTypes[0]: invalid_grant_type" + "errorCode": "invalid_grant_type" } ] }' diff --git a/automationtests/src/main/resources/esignet/OidcClient/OIDCClientResult.hbs b/automationtests/src/main/resources/esignet/OidcClient/OIDCClientResult.hbs index da9ba5fbf4e..ad005e7c3f5 100644 --- a/automationtests/src/main/resources/esignet/OidcClient/OIDCClientResult.hbs +++ b/automationtests/src/main/resources/esignet/OidcClient/OIDCClientResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { "clientId": "{{clientId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/ApproveAPIKey/approveAPIKeyResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/CreatePartner/createPartnerResult.hbs index 25766a41cd9..95dc2a1a1f6 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/CreatePartner/createPartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicy.yml b/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicy.yml index 492e4c53654..55bee8a41cc 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicy.yml +++ b/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicy.yml @@ -14,8 +14,7 @@ DeactivatePolicy: output: ' { "errors": [ { - "errorCode": "PMS_POL_058", - "message": "Status cannot be changed for published policy." + "errorCode": "PMS_POL_058" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicyResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicyResult.hbs deleted file mode 100644 index f23667bf883..00000000000 --- a/automationtests/src/main/resources/esignet/PmsIntegration/DeactivatePolicy/DeactivatePolicyResult.hbs +++ /dev/null @@ -1,9 +0,0 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "message": "{{message}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicy/definePolicyResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicy/definePolicyResult.hbs index 8d602b86e84..23bf0f37163 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicy/definePolicyResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicy/definePolicyResult.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "name": "{{name}}", "desc": "{{desc}}", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + "is_Active": {{is_Active}} + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicyGroup/definePolicyGroupResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicyGroup/definePolicyGroupResult.hbs index c154e311425..101febb627e 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicyGroup/definePolicyGroupResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/DefinePolicyGroup/definePolicyGroupResult.hbs @@ -1,17 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "name": "{{name}}", "desc": "{{desc}}", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + "is_Active": {{is_Active}} + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLK.yml b/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLK.yml index b749a77d2a9..bbfcdd88996 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLK.yml +++ b/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLK.yml @@ -2,6 +2,7 @@ GenerateMispLK: Esignet_GenerateMispLK_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/misps role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/GenerateMispLK/GenerateMispLK outputTemplate: esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult @@ -16,6 +17,7 @@ GenerateMispLK: Esignet_GenerateMispLK_Misp_False_Valid_Smoke_sid: endPoint: /v1/partnermanager/misps role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/GenerateMispLK/GenerateMispLK outputTemplate: esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult @@ -30,6 +32,7 @@ GenerateMispLK: Esignet_GenerateMispLK_Misp_S2_Valid_Smoke_sid: endPoint: /v1/partnermanager/misps role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/GenerateMispLK/GenerateMispLK outputTemplate: esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult.hbs index 1f9a1aa8465..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/GenerateMispLK/GenerateMispLKResult.hbs @@ -1,13 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "providerId": "$IGNORE$", - "licenseKey": "$IGNORE$", - "licenseKeyStatus": "$IGNORE$", - "licenseKeyExpiry": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/PublishPolicy.yml b/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/PublishPolicy.yml index 5a764b74d8d..4660efc7c4b 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/PublishPolicy.yml +++ b/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/PublishPolicy.yml @@ -13,15 +13,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", "policyType": "Auth", "status": "PUBLISHED", - "is_Active": true, + "is_Active": "true", "authType": "bio", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -40,15 +40,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", - "policyType": "Auth", + "policyType": "MISP", "status": "PUBLISHED", - "is_Active": true, - "authType": "bio", + "is_Active": "true", + "authType": "$IGNORE$", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -67,15 +67,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", "policyType": "Auth", "status": "PUBLISHED", - "is_Active": true, + "is_Active": "true", "authType": "bio", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -94,15 +94,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", "policyType": "Auth", "status": "PUBLISHED", - "is_Active": true, - "authType": "bio", + "is_Active": "true", + "authType": "$IGNORE$", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -121,15 +121,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", - "policyType": "Auth", + "policyType": "MISP", "status": "PUBLISHED", - "is_Active": true, - "authType": "bio", + "is_Active": "true", + "authType": "$IGNORE$", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -148,15 +148,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", "policyType": "Auth", "status": "PUBLISHED", - "is_Active": true, + "is_Active": "true", "authType": "bio", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -175,15 +175,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", - "policyType": "Auth", + "policyType": "MISP", "status": "PUBLISHED", - "is_Active": true, - "authType": "bio", + "is_Active": "true", + "authType": "$IGNORE$", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' @@ -202,15 +202,15 @@ createPublishPolicy: output: '{ "policyGroupName": "$IGNORE$", "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": true, + "policyGroupStatus": "true", "policyName": "$IGNORE$", "policyDesc": "$IGNORE$", "policyType": "Auth", "status": "PUBLISHED", - "is_Active": true, + "is_Active": "true", "authType": "bio", "authSubType": "$IGNORE$", - "mandatory": $IGNORE$, + "mandatory": "$IGNORE$", "attributeName": "$IGNORE$", "authTokenType": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/publishPolicyResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/publishPolicyResult.hbs index 14a4a02f493..97dd37b76b8 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/publishPolicyResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/PublishPolicy/publishPolicyResult.hbs @@ -1,37 +1,18 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "policyGroupId": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "policyGroupDesc": "{{policyGroupDesc}}", - "policyGroupStatus": {{policyGroupStatus}}, - "policyGroup_cr_by": "$IGNORE$", - "policyGroup_cr_dtimes": "$IGNORE$", - "policyGroup_up_by": "$IGNORE$", - "policyGroup_upd_dtimes": "$IGNORE$", - "policyId": "$IGNORE$", + "policyGroupStatus": "{{policyGroupStatus}}", "policyName": "{{policyName}}", "policyDesc": "{{policyDesc}}", "policyType": "{{policyType}}", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", + "is_Active": "{{is_Active}}", "policies": { "allowedAuthTypes": [ { "authType": "{{authType}}", "authSubType": "{{authSubType}}", - "mandatory": {{mandatory}} + "mandatory": "{{mandatory}}" } ], "allowedKycAttributes": [ @@ -41,6 +22,5 @@ ], "authTokenType": "{{authTokenType}}" } - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/RequestAPIKey/requestAPIKeyResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/RequestAPIKey/requestAPIKeyResult.hbs index f28509c6269..08de5cbd505 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/RequestAPIKey/requestAPIKeyResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/RequestAPIKey/requestAPIKeyResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "mappingkey": "$IGNORE$", "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicy.yml b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicy.yml index f2ca345aea5..77e32e830f1 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicy.yml +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicy.yml @@ -17,8 +17,7 @@ UpdatePolicy: output: ' { "errors": [ { - "errorCode": "PMS_POL_055", - "message": "Published policy cannot be updated." + "errorCode": "PMS_POL_055" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicyResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicyResult.hbs deleted file mode 100644 index e5e063963f8..00000000000 --- a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePolicy/UpdatePolicyResult.hbs +++ /dev/null @@ -1,18 +0,0 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "id": "$IGNORE$", - "policyGroupName": "{{policyGroupName}}", - "name": "{{name}}", - "desc": "{{desc}}", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml index dd9178cb442..2e3646aefde 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -17,6 +18,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_Misp_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -32,6 +34,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_Kyc_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -47,6 +50,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_NonAuth_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -62,6 +66,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_Misp_False_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -77,6 +82,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_Auth_False_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -92,6 +98,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_Misp_S2_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult @@ -107,6 +114,7 @@ uploadPartnerCert: Esignet_UploadPartnerCert_Auth_S2_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/PmsIntegration/UploadCert/uploadCert outputTemplate: esignet/PmsIntegration/UploadCert/uploadCertResult diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/uploadCertResult.hbs index f175b91d60a..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/uploadCertResult.hbs @@ -1,12 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml index 5d5d3d5a2ba..14ecb4f64fb 100644 --- a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml +++ b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml @@ -2,6 +2,7 @@ SendBindingOtp: ESignet_SendBindingOtp_uin_all_Valid_Smoke_sid: endPoint: /v1/esignet/binding/binding-otp role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp @@ -14,13 +15,14 @@ SendBindingOtp: "otpChannels": [{channel: "email"},{channel: "phone"}] }' output: '{ - "maskedEmail": "$IGNORE$", - "maskedMobile": "$IGNORE$" + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendBindingOtp_Vid_Valid_Smoke_sid: endPoint: /v1/esignet/binding/binding-otp role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp @@ -33,13 +35,14 @@ SendBindingOtp: "otpChannels": [{channel: "email"},{channel: "phone"}] }' output: '{ - "maskedEmail": "$IGNORE$", - "maskedMobile": "$IGNORE$" + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendBindingOtp_uin_Email_Valid_Smoke_sid: endPoint: /v1/esignet/binding/binding-otp role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp @@ -52,13 +55,14 @@ SendBindingOtp: "otpChannels": [{channel: "email"}] }' output: '{ - "maskedEmail": "$IGNORE$", - "maskedMobile": "$IGNORE$" + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendBindingOtp_uin_Phone_Valid_Smoke_sid: endPoint: /v1/esignet/binding/binding-otp role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp @@ -71,8 +75,8 @@ SendBindingOtp: "otpChannels": [{channel: "phone"}] }' output: '{ - "maskedEmail": "$IGNORE$", - "maskedMobile": "$IGNORE$" + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendBindingOtp_uin_Invalid_RequestTime_Neg: diff --git a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtpResult.hbs b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtpResult.hbs index 15af7dc7dd6..c823777f1e9 100644 --- a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtpResult.hbs +++ b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtpResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "maskedEmail": "{{maskedEmail}}", "maskedMobile": "{{maskedMobile}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/SendOtp/SendOtpResult.hbs b/automationtests/src/main/resources/esignet/SendOtp/SendOtpResult.hbs index 15af7dc7dd6..c823777f1e9 100644 --- a/automationtests/src/main/resources/esignet/SendOtp/SendOtpResult.hbs +++ b/automationtests/src/main/resources/esignet/SendOtp/SendOtpResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "maskedEmail": "{{maskedEmail}}", "maskedMobile": "{{maskedMobile}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDC.yml b/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDC.yml index f5ab49b6173..5bb74a2ac8d 100644 --- a/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDC.yml +++ b/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDC.yml @@ -39,8 +39,7 @@ UpdateOIDCClient: output: '{ "errors": [ { - "errorCode": "PMS_IDP_004", - "errorMessage": "$IGNORE$" + "errorCode": "PMS_IDP_004" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDCResult.hbs b/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDCResult.hbs index da9ba5fbf4e..ad005e7c3f5 100644 --- a/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDCResult.hbs +++ b/automationtests/src/main/resources/esignet/UpdateOIDC/UpdateOIDCResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { "clientId": "{{clientId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/UpdateOIDCClient/UpdateOIDCClientResult.hbs b/automationtests/src/main/resources/esignet/UpdateOIDCClient/UpdateOIDCClientResult.hbs index da9ba5fbf4e..ad005e7c3f5 100644 --- a/automationtests/src/main/resources/esignet/UpdateOIDCClient/UpdateOIDCClientResult.hbs +++ b/automationtests/src/main/resources/esignet/UpdateOIDCClient/UpdateOIDCClientResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { "clientId": "{{clientId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml b/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml index 3bd495d51a4..690dfffa94b 100644 --- a/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml +++ b/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml @@ -2,6 +2,7 @@ WalletBinding: ESignet_WalletBinding_uin_OTP_Valid_Smoke: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -38,6 +39,7 @@ WalletBinding: ESignet_WalletBinding_uin_OTP_Phone_Valid_Smoke: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -74,6 +76,7 @@ WalletBinding: ESignet_WalletBinding_uin_OTP_Email_Valid_Smoke: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -110,6 +113,7 @@ WalletBinding: ESignet_WalletBinding_Vid_OTP_Valid_Smoke: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -146,6 +150,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_RequestTime_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -188,6 +193,7 @@ WalletBinding: ESignet_WalletBinding_uin_PastVal_RequestTime_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -230,6 +236,7 @@ WalletBinding: ESignet_WalletBinding_uin_Future_RequestTime_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -272,6 +279,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -314,6 +322,7 @@ WalletBinding: ESignet_WalletBinding_uin_Empty_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -356,6 +365,7 @@ WalletBinding: ESignet_WalletBinding_uin_Null_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -398,6 +408,7 @@ WalletBinding: ESignet_WalletBinding_uin_Missing_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -440,6 +451,7 @@ WalletBinding: ESignet_WalletBinding_uin_SpaceVal_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -466,13 +478,12 @@ WalletBinding: } }' output: '{ - "sendOtpResp": { "errors": [ { - "errorCode": "invalid_individual_id", - "errorMessage": "request.individualId: invalid_individual_id" + "errorCode": "invalid_individual_id" } ], + "sendOtpResp": { "maskedMobile": "$IGNORE$", "sendOtpResTemplate":"esignet/SendBindingOtp/SendBindingOtpResult", "maskedEmail": "$IGNORE$" @@ -482,6 +493,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -524,6 +536,7 @@ WalletBinding: ESignet_WalletBinding_uin_Missing_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -566,6 +579,7 @@ WalletBinding: ESignet_WalletBinding_uin_EmptyVal_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -608,6 +622,7 @@ WalletBinding: ESignet_WalletBinding_uin_SpaceVal_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -650,6 +665,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -692,6 +708,7 @@ WalletBinding: ESignet_WalletBinding_uin_EmptyVal_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -734,6 +751,7 @@ WalletBinding: ESignet_WalletBinding_uin_Missing_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -776,6 +794,7 @@ WalletBinding: ESignet_WalletBinding_uin_SpaceVal_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -818,6 +837,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -860,6 +880,7 @@ WalletBinding: ESignet_WalletBinding_uin_Missing_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -902,6 +923,7 @@ WalletBinding: ESignet_WalletBinding_uin_SpaceVal_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -944,6 +966,7 @@ WalletBinding: ESignet_WalletBinding_uin_Empty_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -986,6 +1009,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1014,8 +1038,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -1028,6 +1051,7 @@ WalletBinding: ESignet_WalletBinding_uin_Missing_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1070,6 +1094,7 @@ WalletBinding: ESignet_WalletBinding_uin_Empty_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1112,6 +1137,7 @@ WalletBinding: ESignet_WalletBinding_uin_SpaceVal_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1140,8 +1166,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -1154,6 +1179,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1182,8 +1208,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "request.format: unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -1196,6 +1221,7 @@ WalletBinding: ESignet_WalletBinding_uin_Empty_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1238,6 +1264,7 @@ WalletBinding: ESignet_WalletBinding_uin_Missing_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1280,6 +1307,7 @@ WalletBinding: ESignet_WalletBinding_uin_SpaceVal_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1308,8 +1336,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -1322,6 +1349,7 @@ WalletBinding: ESignet_WalletBinding_uin_Invalid_publicKey_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1364,6 +1392,7 @@ WalletBinding: ESignet_WalletBinding_uin_Null_publicKey_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1406,6 +1435,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_RequestTime_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1448,6 +1478,7 @@ WalletBinding: ESignet_WalletBinding_vid_PastVal_RequestTime_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1490,6 +1521,7 @@ WalletBinding: ESignet_WalletBinding_vid_Future_RequestTime_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1532,6 +1564,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1574,6 +1607,7 @@ WalletBinding: ESignet_WalletBinding_vid_Empty_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1616,6 +1650,7 @@ WalletBinding: ESignet_WalletBinding_vid_Null_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1658,6 +1693,7 @@ WalletBinding: ESignet_WalletBinding_vid_Missing_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1700,6 +1736,7 @@ WalletBinding: ESignet_WalletBinding_vid_SpaceVal_IndividualId_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1726,13 +1763,12 @@ WalletBinding: } }' output: '{ - "sendOtpResp": { "errors": [ { - "errorCode": "invalid_individual_id", - "errorMessage": "request.individualId: invalid_individual_id" + "errorCode": "invalid_individual_id" } ], + "sendOtpResp": { "maskedMobile": "$IGNORE$", "sendOtpResTemplate":"esignet/SendBindingOtp/SendBindingOtpResult", "maskedEmail": "$IGNORE$" @@ -1742,6 +1778,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1784,6 +1821,7 @@ WalletBinding: ESignet_WalletBinding_vid_Missing_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1826,6 +1864,7 @@ WalletBinding: ESignet_WalletBinding_vid_EmptyVal_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1868,6 +1907,7 @@ WalletBinding: ESignet_WalletBinding_vid_SpaceVal_AuthFactorType_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1910,6 +1950,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1952,6 +1993,7 @@ WalletBinding: ESignet_WalletBinding_vid_EmptyVal_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -1994,6 +2036,7 @@ WalletBinding: ESignet_WalletBinding_vid_Missing_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2036,6 +2079,7 @@ WalletBinding: ESignet_WalletBinding_vid_SpaceVal_Challenge_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2078,6 +2122,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2120,6 +2165,7 @@ WalletBinding: ESignet_WalletBinding_vid_Missing_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2162,6 +2208,7 @@ WalletBinding: ESignet_WalletBinding_vid_SpaceVal_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2204,6 +2251,7 @@ WalletBinding: ESignet_WalletBinding_vid_Empty_Formate_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2246,6 +2294,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2274,8 +2323,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -2288,6 +2336,7 @@ WalletBinding: ESignet_WalletBinding_vid_Missing_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2330,6 +2379,7 @@ WalletBinding: ESignet_WalletBinding_vid_Empty_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2372,6 +2422,7 @@ WalletBinding: ESignet_WalletBinding_vid_SpaceVal_authFactorType1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2400,8 +2451,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -2414,6 +2464,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2442,8 +2493,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "request.format: unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -2456,6 +2506,7 @@ WalletBinding: ESignet_WalletBinding_vid_Empty_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2498,6 +2549,7 @@ WalletBinding: ESignet_WalletBinding_vid_Missing_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2540,6 +2592,7 @@ WalletBinding: ESignet_WalletBinding_vid_SpaceVal_format1_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2568,8 +2621,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "errorMessage": "unsupported_challenge_format" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { @@ -2582,6 +2634,7 @@ WalletBinding: ESignet_WalletBinding_vid_Invalid_publicKey_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding @@ -2624,6 +2677,7 @@ WalletBinding: ESignet_WalletBinding_vid_Null_publicKey_Neg: endPoint: /v1/esignet/binding/wallet-binding role: mobileauth + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: esignet/WalletBinding/WalletBinding diff --git a/automationtests/src/main/resources/esignet/WalletBinding/WalletBindingResult.hbs b/automationtests/src/main/resources/esignet/WalletBinding/WalletBindingResult.hbs index 720501904bf..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/WalletBinding/WalletBindingResult.hbs +++ b/automationtests/src/main/resources/esignet/WalletBinding/WalletBindingResult.hbs @@ -1,9 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": { - "encryptedWalletBindingId": "$IGNORE$", - "certificate": "$IGNORE$", - "expireDateTime": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/error.hbs b/automationtests/src/main/resources/esignet/error.hbs index f8ac44a20d3..b31f5fddd9d 100644 --- a/automationtests/src/main/resources/esignet/error.hbs +++ b/automationtests/src/main/resources/esignet/error.hbs @@ -10,8 +10,7 @@ "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "errorMessage": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} From cb615da3ce7894d78e9b6a064b4fee588240f8ab Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Mon, 28 Aug 2023 12:22:16 +0530 Subject: [PATCH 073/204] MOSIP-29080 --- automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml | 2 -- .../src/main/resources/preReg/SendOtp/sendotpResult.hbs | 1 - .../src/main/resources/preReg/ValidateOtp/ValidateOtp.yml | 2 -- .../src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs | 1 - 4 files changed, 6 deletions(-) diff --git a/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml b/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml index 8a7d96fe08b..fc6ce429857 100644 --- a/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml +++ b/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml @@ -12,7 +12,6 @@ SendOtp: "id": "mosip.pre-registration.login.sendotp" }' output: '{ - "message": "Sms Request Sent", "status": "success" }' Prereg_SendOtp_All_Valid_Smoke_email_sid: @@ -28,6 +27,5 @@ SendOtp: "id": "mosip.pre-registration.login.sendotp" }' output: '{ - "message": "Email Request submitted", "status": "success" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs b/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs index e9916f7c67c..0137f52daaa 100644 --- a/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs +++ b/automationtests/src/main/resources/preReg/SendOtp/sendotpResult.hbs @@ -1,6 +1,5 @@ { "response": { - "message": "{{message}}", "status": "{{status}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml b/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml index 69b5d3e9e08..6623b052042 100644 --- a/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml +++ b/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml @@ -13,7 +13,6 @@ ValidateOtp: "id": "mosip.pre-registration.login.useridotp" }' output: '{ - "message": "VALIDATION_SUCCESSFUL", "status": "success" }' Prereg_SendOtp_All_Valid_Smoke_email_sid: @@ -30,6 +29,5 @@ ValidateOtp: "id": "mosip.pre-registration.login.useridotp" }' output: '{ - "message": "VALIDATION_SUCCESSFUL", "status": "success" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs b/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs index e9916f7c67c..0137f52daaa 100644 --- a/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs +++ b/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs @@ -1,6 +1,5 @@ { "response": { - "message": "{{message}}", "status": "{{status}}" } } \ No newline at end of file From 705967db33fc8cb5248a45139bdbb5835a9a69dc Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Mon, 28 Aug 2023 12:40:09 +0530 Subject: [PATCH 074/204] MOSIP-29080 --- .../CancelApplicationsAppointment.yml | 5 ++--- .../preReg/CancelAppointment/CancelAppointment.yml | 5 ++--- .../preReg/CancelAppointment/cancelAppointmentResult.hbs | 3 --- .../preReg/DeleteAllDocForaPRID/DeleteAllDocForaPRID.yml | 3 +-- .../DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs | 3 --- .../DeleteSpecificDocForaPRID.yml | 9 ++++----- .../deleteSpecificDocForaPRIDResult.hbs | 3 --- .../preReg/SendNotifications/SendNotifications.yml | 7 +++---- .../preReg/SendNotifications/sendNotificationsResult.hbs | 3 --- 9 files changed, 12 insertions(+), 29 deletions(-) diff --git a/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/CancelApplicationsAppointment.yml b/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/CancelApplicationsAppointment.yml index 280e83b4422..b47992d8b33 100644 --- a/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/CancelApplicationsAppointment.yml +++ b/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/CancelApplicationsAppointment.yml @@ -2,6 +2,7 @@ CancelApplicationsAppointment: Prereg_CancelApplicationsAppointment_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/appointment/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: preReg/CancelApplicationsAppointment/cancelApplicationsAppointment outputTemplate: preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult @@ -9,7 +10,6 @@ CancelApplicationsAppointment: "preRegistrationId": "$ID:CreatePrereg_Smoke_CancelApplicationsAppointment_sid_preRegistrationId$" }' output: '{ -"message": "Appointment for the selected application has been successfully cancelled" }' Prereg_CancelApplicationsAppointment_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/applications/appointment/{preRegistrationId} @@ -23,8 +23,7 @@ CancelApplicationsAppointment: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CancelAppointment/CancelAppointment.yml b/automationtests/src/main/resources/preReg/CancelAppointment/CancelAppointment.yml index 9b83f5811a7..bf8298d1fc3 100644 --- a/automationtests/src/main/resources/preReg/CancelAppointment/CancelAppointment.yml +++ b/automationtests/src/main/resources/preReg/CancelAppointment/CancelAppointment.yml @@ -2,6 +2,7 @@ CancelAppointment: Prereg_CancelAppointment_All_Valid_Smoke_sid: endPoint: /preregistration/v1/appointment/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: preReg/CancelAppointment/cancelAppointment outputTemplate: preReg/CancelAppointment/cancelAppointmentResult @@ -9,7 +10,6 @@ CancelAppointment: "preRegistrationId": "$ID:CreatePrereg_Smoke_CancellAppointment_sid_preRegistrationId$" }' output: '{ -"message": "Appointment for the selected application has been successfully cancelled" }' Prereg_CancelAppointment_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/appointment/{preRegistrationId} @@ -23,8 +23,7 @@ CancelAppointment: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs b/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/CancelAppointment/cancelAppointmentResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/DeleteAllDocForaPRID.yml b/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/DeleteAllDocForaPRID.yml index 20054e60284..5d84ca410e9 100644 --- a/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/DeleteAllDocForaPRID.yml +++ b/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/DeleteAllDocForaPRID.yml @@ -2,6 +2,7 @@ DeleteAllDocForaPRID: Prereg_DeletePreRegistration_All_Valid_Smoke_sid: endPoint: /preregistration/v1/documents/preregistration/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: preReg/DeleteAllDocForaPRID/deleteAllDocForaPRID outputTemplate: preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult @@ -9,7 +10,6 @@ DeleteAllDocForaPRID: "preRegistrationId": "$ID:CreatePrereg_Smoke_alldel_sid_preRegistrationId$" }' output: '{ -"message": "All documents assosiated with requested pre-registration id deleted sucessfully" }' Prereg_DeletePreRegistration_InValid_preRegistrationId_sid: endPoint: /preregistration/v1/documents/preregistration/{preRegistrationId} @@ -24,7 +24,6 @@ DeleteAllDocForaPRID: "errors": [ { "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs b/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteAllDocForaPRID/deleteAllDocForaPRIDResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml index 5f970fe5d40..2b80312e816 100644 --- a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml +++ b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/DeleteSpecificDocForaPRID.yml @@ -2,6 +2,7 @@ DeleteSpecificDocForaPRID: Prereg_DeleteSpecificDocForaPRID_All_Valid_Smoke_sid: endPoint: /preregistration/v1/documents/{documentId}?preRegistrationId={preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRID outputTemplate: preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult @@ -10,7 +11,7 @@ DeleteSpecificDocForaPRID: "documentId": "$ID:UploadDocument_All_Valid_Smoke_sid_docId$" }' output: '{ -"message": "Document successfully deleted" + }' Prereg_DeletePreRegistration_inValid_preRegistrationId_sid: endPoint: /preregistration/v1/documents/{documentId}?preRegistrationId={preRegistrationId} @@ -25,8 +26,7 @@ DeleteSpecificDocForaPRID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' @@ -43,8 +43,7 @@ DeleteSpecificDocForaPRID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_DOC_005", - "message": "Documents is not found for the requested pre-registration id" + "errorCode": "PRG_PAM_DOC_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/DeleteSpecificDocForaPRID/deleteSpecificDocForaPRIDResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml b/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml index a687f8d6bcf..c8b8d6d5675 100644 --- a/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml +++ b/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml @@ -2,6 +2,7 @@ SendNotifications: Prereg_SendNotifications_All_Valid_Smoke: endPoint: /preregistration/v1/notification role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/SendNotifications/sendNotifications_$LANGNUMBER$ outputTemplate: preReg/SendNotifications/sendNotificationsResult @@ -19,11 +20,11 @@ SendNotifications: "isBatch":false }' output: '{ - "message": "Email and sms request successfully submitted" }' Prereg_SendNotifications_Notify_All_Valid_Smoke: endPoint: /preregistration/v1/notification/notify role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/SendNotifications/sendNotificationsNotify outputTemplate: preReg/SendNotifications/sendNotificationsResult @@ -40,7 +41,6 @@ SendNotifications: "isBatch":true }' output: '{ - "message": "Email and sms request successfully submitted" }' Prereg_SendNotifications_InValid_id: endPoint: /preregistration/v1/notification @@ -64,8 +64,7 @@ SendNotifications: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' diff --git a/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs b/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs +++ b/automationtests/src/main/resources/preReg/SendNotifications/sendNotificationsResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file From 3d57da4c079414363f070fbf039127780338a7da Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Mon, 28 Aug 2023 12:52:36 +0530 Subject: [PATCH 075/204] MOSIP-29086 --- .../activateDeactivatePartnerResult.hbs | 7 +--- .../activateDeactivatePartnerApiKeyResult.hbs | 7 +--- .../createBioExtractorsResult.hbs | 20 ----------- .../DeviceDetailsFilter.yml | 3 -- .../deviceDetailsFilterResult.hbs | 7 +--- .../DeviceSubTypeFilter.yml | 1 - .../deviceSubTypeFilterResult.hbs | 7 +--- .../DeviceTypeFilter/DeviceTypeFilter.yml | 1 - .../deviceTypeFilterResult.hbs | 7 +--- .../PartnerApiKeyRequestFilter.yml | 1 - .../partnerApiKeyRequestFilterResult.hbs | 7 +--- .../PartnerFilter/PartnerFilter.yml | 1 - .../PartnerFilter/partnerFilterResult.hbs | 7 +--- .../policyGroupFilterResult.hbs | 7 +--- .../ServiceToFilterSBI/ServiceToFilterSBI.yml | 1 - .../serviceToFilterSBIResult.hbs | 11 ++---- .../CreatePartner/createPartnerResult.hbs | 6 +--- .../UploadCert/uploadCertResult.hbs | 10 ------ .../uploadCertificateResult.hbs | 10 ++---- .../ApproveAPIKey/approveAPIKeyResult.hbs | 7 +--- .../CreatePartner/createPartnerResult.hbs | 7 +--- .../GenerateApiKey/generateApiKeyResult.hbs | 9 +---- .../RequestAPIKey/RequestAPIKey.yml | 1 - .../RequestAPIKey/requestAPIKeyResult.hbs | 9 ++--- .../UploadCert/uploadCertResult.hbs | 10 ------ .../getAllPolicyGroupResult.hbs | 22 ------------ .../getApiKeyRequestsResult.hbs | 20 ----------- .../getBioExtractorsResult.hbs | 20 ----------- .../GetPartnerApiKeyRequest.yml | 1 - .../getPartnerApiKeyRequestResult.hbs | 17 --------- .../partner/GetPartners/getPartnersResult.hbs | 13 +------ .../GetPartnersPolicy/GetPartnersPolicy.yml | 3 +- .../getPartnersPolicyResult.hbs | 27 ++------------ .../getPolicyForApiKeyResult.hbs | 10 ++---- ...orMappedPartnerAndCredentialtypeResult.hbs | 23 ++---------- .../partner/GetRoles/getRolesResult.hbs | 6 ---- .../GetValueForConfigKey.yml | 2 -- .../getValueForConfigKeyResult.hbs | 6 +--- .../MapPartnerAndPolicytoCredentialType.yml | 2 -- ...PartnerAndPolicytoCredentialTypeResult.hbs | 7 +--- .../CreateMispLicense/CreateMispLicense.yml | 2 -- .../createMispLicenseResult.hbs | 11 ++---- .../FilterMispLicense/FilterMispLicense.yml | 3 +- .../filterMispLicenseResult.hbs | 7 +--- .../getMISPLicenseByMispIDResult.hbs | 12 ++----- .../GetMispLicense/getMispLicenseResult.hbs | 19 ++-------- .../searchMispLicenseResult.hbs | 27 -------------- .../updateMispLicenseResult.hbs | 11 ++---- .../PartnerSearch/PartnerSearchResult.hbs | 35 ------------------- .../partner/PartnerSearch/partnerSearch.yml | 12 ++----- .../CreatePartner/createPartnerResult.hbs | 6 +--- .../GetPartnerDetailsResult.hbs | 6 ---- .../UpdatePrintPartnerResult.hbs | 7 +--- .../PrintPartner/UploadCert/UploadCert.yml | 1 - .../UploadCert/uploadCertResult.hbs | 10 ------ .../uploadCertificateResult.hbs | 10 ++---- .../createSearchDeviceDetailsResult.hbs | 23 ------------ .../createSearchDeviceTypeResult.hbs | 14 +------- .../createSearchPartnerResult.hbs | 29 ++------------- .../searchPartnerApiKeyResult.hbs | 31 ---------------- .../SearchPartnerApiRequestKey.yml | 15 -------- .../searchPartnerApiRequestKeyResult.hbs | 23 ++---------- .../createSearchPartnerType.yml | 2 -- .../createSearchPartnerTypeResult.hbs | 18 ++-------- .../SearchPolicy/createSearchPolicy.yml | 25 ------------- .../SearchPolicy/createSearchPolicyResult.hbs | 26 ++------------ .../createSearchPolicyGroup.yml | 1 - .../createSearchPolicyGroupResult.hbs | 21 ++--------- .../createSearchRegisteredDeviceResult.hbs | 31 ++-------------- .../createSearchSecureBiometric.yml | 15 -------- .../createSearchSecureBiometricResult.hbs | 25 ++----------- .../updatePolicyAgainstApiKeyResult.hbs | 7 +--- .../updatePolicyGroupForPartnerResult.hbs | 7 +--- .../verifyPartnersEmailResult.hbs | 10 ++---- .../apiKeyAutoApprovalResult.hbs | 11 ++---- .../AddContacts/addContactResult.hbs | 6 +--- .../ApproveAPIKey/approveAPIKeyResult.hbs | 7 +--- .../CreatePartner/CreatePartner.yml | 6 ++-- .../CreatePartner/createPartnerResult.hbs | 7 +--- .../GetCertificate/getCertResult.hbs | 10 ------ .../GetPartner/getPartnerResult.hbs | 18 ++-------- .../RejectAPIKey/rejectAPIKeyResult.hbs | 7 +--- .../RequestAPIKey/RequestAPIKey.yml | 3 -- .../RequestAPIKey/requestAPIKeyResult.hbs | 8 +---- .../UpdatePartner/updatePartnerResult.hbs | 7 +--- .../authPartner/UploadCert/UploadCert.yml | 6 ++-- .../UploadCert/uploadCertResult.hbs | 10 ------ .../UploadCertificate/UploadCertificate.yml | 3 +- .../uploadCertificateResult.hbs | 10 ++---- .../apiKeyAutoApprovalResult.hbs | 11 ++---- .../addBioExtractorsResult.hbs | 7 +--- .../ApproveAPIKey/approveAPIKeyResult.hbs | 7 +--- .../CreatePartner/createPartnerResult.hbs | 7 +--- .../GetCertificate/GetCert.yml | 1 - .../GetCertificate/getCertResult.hbs | 10 ------ .../GetPartner/getPartnerResult.hbs | 17 ++------- .../RejectAPIKey/rejectAPIKeyResult.hbs | 7 +--- .../RequestAPIKey/RequestAPIKey.yml | 2 -- .../RequestAPIKey/requestAPIKeyResult.hbs | 9 +---- .../UploadCert/uploadCertResult.hbs | 10 +----- .../uploadCertificateResult.hbs | 10 ++---- .../mapDeviceWithSBIResult.hbs | 7 +--- .../removeMapDeviceWithSBIResult.hbs | 7 +--- .../approveSecureBiometricInterfaceResult.hbs | 7 +--- .../create/CreateSecureBiometricInterface.yml | 2 -- .../createSecureBiometricInterfaceResult.hbs | 8 ----- .../rejectSecureBiometricInterfaceResult.hbs | 7 +--- .../deregistration/deRegisterDeviceResult.hbs | 6 ---- .../approve/approveFtpChipDetailResult.hbs | 7 +--- .../create/createFTPChipDetailResult.hbs | 7 +--- .../ftmChipDetails/get/GetFtpChipDetail.yml | 1 - .../get/getFtpChipDetailResult.hbs | 6 ---- .../reject/rejectFtpChipDetailResult.hbs | 7 +--- .../update/updateFtpChipDetailResult.hbs | 7 +--- .../uploadcert/Uploadcertificate.yml | 1 - .../uploadcert/uploadcertificateResult.hbs | 10 ------ .../approve/approveDeviceDetailResult.hbs | 7 +--- .../create/CreateDeviceDetail.yml | 2 -- .../create/createDeviceDetailResult.hbs | 7 +--- .../reject/rejectDeviceDetailResult.hbs | 7 +--- .../update/updateDeviceDetailResult.hbs | 4 +-- .../registration/registereDeviceResult.hbs | 6 ---- .../CreatePartner/createPartnerResult.hbs | 10 ++---- .../devicePartner/GetCertificate/GetCert.yml | 1 - .../GetCertificate/getCertResult.hbs | 10 ------ .../GetPartner/getPartnerResult.hbs | 17 ++------- .../UploadCert/uploadCertResult.hbs | 10 +----- .../uploadCertificateResult.hbs | 10 ++---- .../src/main/resources/partner/error.hbs | 10 +----- .../CreatePartner/createPartnerResult.hbs | 7 +--- .../mispPartner/GetCertificate/GetCert.yml | 1 - .../GetCertificate/getCertResult.hbs | 10 ------ .../GetPartner/getPartnerResult.hbs | 17 ++------- .../UploadCert/uploadCertResult.hbs | 10 ------ .../uploadCertificateResult.hbs | 10 ++---- .../defineDataSharePolicyResult.hbs | 14 ++------ .../DefinePolicy/definePolicyResult.hbs | 12 ++----- .../DefinePolicyGroup/DefinePolicyGroup.yml | 4 --- .../definePolicyGroupResult.hbs | 12 +------ .../policy/GetPolicy/getPolicyResult.hbs | 25 +------------ .../GetPolicyGroup/getPolicyGroupResult.hbs | 17 ++------- .../publishDataSharePolicyResult.hbs | 23 +----------- .../PublishPolicy/publishPolicyResult.hbs | 22 +----------- .../partner/policy/Search/SearchPolicy.yml | 11 ++---- .../UpdatePolicy/updatePolicyResult.hbs | 12 +------ .../updatePolicyGroupResult.hbs | 14 ++------ .../updatePolicyStatusResult.hbs | 7 +--- 147 files changed, 136 insertions(+), 1345 deletions(-) diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs b/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs index f6c477a5bd8..ba212b70ab8 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/CreateBioExtractors/createBioExtractorsResult.hbs b/automationtests/src/main/resources/partner/CreateBioExtractors/createBioExtractorsResult.hbs index 27f76e933bc..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/CreateBioExtractors/createBioExtractorsResult.hbs +++ b/automationtests/src/main/resources/partner/CreateBioExtractors/createBioExtractorsResult.hbs @@ -1,22 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "extractors": [ - {{#each extractors}} - { - "attributeName": "$IGNORE$", - "biometric": "$IGNORE$", - "extractor": { - "provider": "$IGNORE$", - "version": "$IGNORE$" - } - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml index 216975dac80..69ad8a5dc55 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml @@ -35,7 +35,6 @@ DeviceDetailsFilter: }' output: '{ "fieldID": "id", - "fieldValue": "$IGNORE$", "fieldCode": "device-id-123" }' partner_DeviceDetailsFilter_Invalid_EmptyFilterType: @@ -50,7 +49,6 @@ DeviceDetailsFilter: "type": "", "text": "device-id-123" }], - "optionalFilters": "$IGNORE$", "purpose": "REGISTRATION", "requesttime": "$TIMESTAMP$" }' @@ -104,7 +102,6 @@ DeviceDetailsFilter: "errors": [ { "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult.hbs index a2b87f2c5cd..2a0624ba197 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml index a6649a6640f..c9f0628d337 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml @@ -123,7 +123,6 @@ DeviceSubTypeFilter: "errors": [ { "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilterResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilterResult.hbs index a2b87f2c5cd..2a0624ba197 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilterResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml index 3c3c3a3a4c0..93263e0a4c6 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml @@ -104,7 +104,6 @@ DeviceTypeFilter: "errors": [ { "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/deviceTypeFilterResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/deviceTypeFilterResult.hbs index a2b87f2c5cd..2a0624ba197 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/deviceTypeFilterResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/deviceTypeFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml index df36c979f96..bf3a4122045 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml @@ -107,7 +107,6 @@ PartnerApiKeyRequestFilter: "errors": [ { "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/partnerApiKeyRequestFilterResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/partnerApiKeyRequestFilterResult.hbs index a2b87f2c5cd..2a0624ba197 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/partnerApiKeyRequestFilterResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/partnerApiKeyRequestFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml index 97ff0d5e5fd..2f04c6a3a95 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml @@ -77,7 +77,6 @@ PartnerFilter: "errors": [ { "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/partnerFilterResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/partnerFilterResult.hbs index a2b87f2c5cd..2a0624ba197 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/partnerFilterResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/partnerFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/policyGroupFilterResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/policyGroupFilterResult.hbs index a2b87f2c5cd..2a0624ba197 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/policyGroupFilterResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/policyGroupFilterResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} @@ -14,6 +10,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml index af8ca00c271..308943b8ee6 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml @@ -117,7 +117,6 @@ ServiceToFilterSBI: "errors": [ { "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBIResult.hbs b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBIResult.hbs index d6c83f67e8e..34902148c60 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBIResult.hbs +++ b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBIResult.hbs @@ -1,19 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": $IGNORE$, "response": { "filters": [ {{#each filters}} { - "fieldID": "$IGNORE$", - "fieldValue": "{{fieldValue}}", - "fieldCode": "$IGNORE$" + "fieldValue": "{{fieldValue}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FtpPartner/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/FtpPartner/CreatePartner/createPartnerResult.hbs index 9e84194f547..bda15db3435 100644 --- a/automationtests/src/main/resources/partner/FtpPartner/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/FtpPartner/CreatePartner/createPartnerResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FtpPartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/FtpPartner/UploadCert/uploadCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/FtpPartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/FtpPartner/UploadCert/uploadCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FtpPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/FtpPartner/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/partner/FtpPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/FtpPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/CreatePartner/createPartnerResult.hbs index 25766a41cd9..95dc2a1a1f6 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/CreatePartner/createPartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/GenerateApiKey/generateApiKeyResult.hbs b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/GenerateApiKey/generateApiKeyResult.hbs index b6cdb8f93bf..fa7ef4e4cb7 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/GenerateApiKey/generateApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/GenerateApiKey/generateApiKeyResult.hbs @@ -1,13 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "apiKey": "$IGNORE$", "label": "{{label}}", - "policyId": "$IGNORE$", "partnerId": "{{partnerId}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/RequestAPIKey.yml b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/RequestAPIKey.yml index 59f6343c775..8bad97c62d1 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/RequestAPIKey.yml +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/RequestAPIKey.yml @@ -11,6 +11,5 @@ RequestAPIKeyForAuthPartner: "requesttime": "$TIMESTAMP$" }' output: '{ - "mappingkey": "$IGNORE$", "message": "Policy mapping request submitted successfully." }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/requestAPIKeyResult.hbs b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/requestAPIKeyResult.hbs index f28509c6269..444ebd21c44 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/requestAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/RequestAPIKey/requestAPIKeyResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", + "response": { - "mappingkey": "$IGNORE$", "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/uploadCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/uploadCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetAllPolicyGroup/getAllPolicyGroupResult.hbs b/automationtests/src/main/resources/partner/GetAllPolicyGroup/getAllPolicyGroupResult.hbs index 72e8ba6b216..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GetAllPolicyGroup/getAllPolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/GetAllPolicyGroup/getAllPolicyGroupResult.hbs @@ -1,24 +1,2 @@ { - "id": null, - "version": null, - "responsetime": "2021-08-16T06:10:25.470Z", - "response": [ - { - "policyGroup": { - "id": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": $IGNORE$, - "desc": "$IGNORE$", - "isActive": $IGNORE$, - "isDeleted": $IGNORE$, - "name": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "userId": "$IGNORE$" - }, - "policies": "$IGNORE$" - } - ], - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetApiKeyRequests/getApiKeyRequestsResult.hbs b/automationtests/src/main/resources/partner/GetApiKeyRequests/getApiKeyRequestsResult.hbs index 17d9417953a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GetApiKeyRequests/getApiKeyRequestsResult.hbs +++ b/automationtests/src/main/resources/partner/GetApiKeyRequests/getApiKeyRequestsResult.hbs @@ -1,22 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "apikeyRequests":[ - {{#each apikeyRequests}} - { - "partnerID": "$IGNORE$", - "status": "$IGNORE$", - "organizationName": "$IGNORE$", - "policyId": "$IGNORE$", - "policyDesc": "$IGNORE$", - "apiKeyReqNo": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetBioExtractors/getBioExtractorsResult.hbs b/automationtests/src/main/resources/partner/GetBioExtractors/getBioExtractorsResult.hbs index 27f76e933bc..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GetBioExtractors/getBioExtractorsResult.hbs +++ b/automationtests/src/main/resources/partner/GetBioExtractors/getBioExtractorsResult.hbs @@ -1,22 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "extractors": [ - {{#each extractors}} - { - "attributeName": "$IGNORE$", - "biometric": "$IGNORE$", - "extractor": { - "provider": "$IGNORE$", - "version": "$IGNORE$" - } - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml b/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml index 13d389e1e5f..ccc96d71c19 100644 --- a/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml +++ b/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml @@ -9,7 +9,6 @@ GetPartnerApiKeyRequest: "partnerId": "Tech-123" }' output: '{ - "errors": "$IGNORE$" }' Partner_GetPartnerApiKeyRequest_InValid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/apikey/request diff --git a/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/getPartnerApiKeyRequestResult.hbs b/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/getPartnerApiKeyRequestResult.hbs index d61accac664..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/getPartnerApiKeyRequestResult.hbs +++ b/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/getPartnerApiKeyRequestResult.hbs @@ -1,19 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": [ - {{#each response}} - { - "apiKeyReqID": "$IGNORE$", - "apiKeyRequestStatus": "$IGNORE$", - "partnerApiKey": "$IGNORE$", - "apikeyStatus": "$IGNORE$", - "validityTill": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartners/getPartnersResult.hbs b/automationtests/src/main/resources/partner/GetPartners/getPartnersResult.hbs index 44438ed912d..4cf411ebb9e 100644 --- a/automationtests/src/main/resources/partner/GetPartners/getPartnersResult.hbs +++ b/automationtests/src/main/resources/partner/GetPartners/getPartnersResult.hbs @@ -1,23 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partners":[ {{#each policies}} { - "partnerID": "$IGNORE$", - "status": "$IGNORE$", - "organizationName": "$IGNORE$", - "contactNumber": "$IGNORE$", - "emailId": "$IGNORE$", - "address": "$IGNORE$", "partnerType": "{{partnerType}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml index b678bc93b54..92da4c83dd5 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml @@ -16,8 +16,7 @@ GetPartnersPolicy: "policyGroupName": "mpolicygroup-default-auth", "policyId": "mpolicy-default-auth", "policyName": "mpolicy-default-auth", - "status": "PUBLISHED", - "policies": "$IGNORE$" + "status": "PUBLISHED" }' partner_GetPartnersPolicy_invalid_partnerId: diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs b/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs index 80a333645ca..08a89e13d3c 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs @@ -1,32 +1,9 @@ { -"id": "$IGNORE$", -"version": "$IGNORE$", -"responsetime": "$IGNORE$", "response": { "policyGroupId": "{{policyGroupId}}", "policyGroupName": "{{policyGroupName}}", - "policyGroupDesc": "$IGNORE$", - "policyGroupStatus": $IGNORE$, - "policyGroup_cr_by": "$IGNORE$", - "policyGroup_cr_dtimes": "$IGNORE$", - "policyGroup_up_by": "$IGNORE$", - "policyGroup_upd_dtimes": "$IGNORE$", "policyId": "policyId", "policyName": "policyName", - "policyDesc": "$IGNORE$", - "policyType": "$IGNORE$", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "{{status}}", - "version": "$IGNORE$", - "schema": "$IGNORE$", - "is_Active": $IGNORE$, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", - - "policies": "$IGNORE$" -}, - "errors": "$IGNORE$" + "status": "{{status}}" +} } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPolicyForApiKey/getPolicyForApiKeyResult.hbs b/automationtests/src/main/resources/partner/GetPolicyForApiKey/getPolicyForApiKeyResult.hbs index c082ad7decd..29fd7a0bd35 100644 --- a/automationtests/src/main/resources/partner/GetPolicyForApiKey/getPolicyForApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GetPolicyForApiKey/getPolicyForApiKeyResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "partnerID": "{{partnerID}}", - "policyId": "$IGNORE$" - }, - "errors": "$IGNORE$" + "partnerID": "{{partnerID}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs b/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs index f73bb9de72e..d65590afef7 100644 --- a/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs +++ b/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs @@ -1,26 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "credentialType": "{{credentialType}}", - "policyId": "$IGNORE$", - "policyName": "{{policyName}}", - "policyDesc": "$IGNORE$", - "policyType": "$IGNORE$", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", - "is_Active": "$IGNORE$", - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", - "policies": "$IGNORE$" - }, - "errors": "$IGNORE$" + "policyName": "{{policyName}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetRoles/getRolesResult.hbs b/automationtests/src/main/resources/partner/GetRoles/getRolesResult.hbs index 6f535a41eda..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GetRoles/getRolesResult.hbs +++ b/automationtests/src/main/resources/partner/GetRoles/getRolesResult.hbs @@ -1,8 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml b/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml index 3fcb4535017..7a18d4c7aaa 100644 --- a/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml +++ b/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml @@ -11,7 +11,6 @@ GetValueForConfigKey: }' output: '{ "key": "pmp.datashare.policy.schema", - "value": "$IGNORE$" } ' partner_GetValueForConfigKey_allValid_smoke: @@ -26,5 +25,4 @@ GetValueForConfigKey: }' output: '{ "key": "abcd", - "value": "$IGNORE$" } ' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs b/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs index 07221bfcb53..bf0fa3d7dc0 100644 --- a/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "key": "{{key}}", "value": "{{value}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml index 0cb9415dad8..11aacbb2fbe 100644 --- a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml +++ b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml @@ -47,7 +47,6 @@ MapPartnerAndPolicytoCredentialType: "errors": [ { "errorCode": "PMS_PRT_098", - "message": "$IGNORE$" } ] }' @@ -66,7 +65,6 @@ MapPartnerAndPolicytoCredentialType: "errors": [ { "errorCode": "PMS_PRT_072", - "message": "$IGNORE$" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs +++ b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml index f188e9b663a..d708e9b4dbc 100644 --- a/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml @@ -11,7 +11,6 @@ CreateMispLicense: }' output: '{ "providerId": "MISP", - "licenseKey": "$IGNORE$", "licenseKeyStatus": "Active" }' Partner_CreateMispLicense_MispLicense_allValid_smoke_sid: @@ -26,7 +25,6 @@ CreateMispLicense: }' output: '{ "providerId": "MISP2", - "licenseKey": "$IGNORE$", "licenseKeyStatus": "Active" }' Partner_CreateMispLicense_InValid_ProviderId: diff --git a/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/createMispLicenseResult.hbs b/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/createMispLicenseResult.hbs index bbad0f90a20..3e674c07f72 100644 --- a/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/createMispLicenseResult.hbs +++ b/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/createMispLicenseResult.hbs @@ -1,13 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "providerId": "{{providerId}}", - "licenseKey": "$IGNORE$", - "licenseKeyStatus": "{{licenseKeyStatus}}", - "licenseKeyExpiry": "$IGNORE$" - }, - "errors": "$IGNORE$" + "licenseKeyStatus": "{{licenseKeyStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml index ae036e025a8..a7921dd24f3 100644 --- a/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml @@ -114,8 +114,7 @@ FilterMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", - "message": "$IGNORE$" + "errorCode": "PMS-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/filterMispLicenseResult.hbs b/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/filterMispLicenseResult.hbs index 8f21fdb948a..729a9c92899 100644 --- a/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/filterMispLicenseResult.hbs +++ b/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/filterMispLicenseResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -13,6 +9,5 @@ {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/getMISPLicenseByMispIDResult.hbs b/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/getMISPLicenseByMispIDResult.hbs index e1eb24a8cd5..16c76e84278 100644 --- a/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/getMISPLicenseByMispIDResult.hbs +++ b/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/getMISPLicenseByMispIDResult.hbs @@ -1,13 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "providerId": "{{providerId}}", - "licenseKey": "$IGNORE$", - "licenseKeyStatus": "$IGNORE$", - "licenseKeyExpiry": "$IGNORE$" - }, - "errors": "$IGNORE$" + "providerId": "{{providerId}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/getMispLicenseResult.hbs b/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/getMispLicenseResult.hbs index 20bdfdbc252..597526496f8 100644 --- a/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/getMispLicenseResult.hbs +++ b/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/getMispLicenseResult.hbs @@ -1,25 +1,10 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": [ {{#each response}} { - "mispId": "$IGNORE$", - "licenseKey": "$IGNORE$", - "validFromDate": "$IGNORE$", - "validToDate": "$IGNORE$", - "isActive": {{isActive}}, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} - ], - "errors": "$IGNORE$" + ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/searchMispLicenseResult.hbs b/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/searchMispLicenseResult.hbs index 4ca097db0a8..2c63c085104 100644 --- a/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/searchMispLicenseResult.hbs +++ b/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/searchMispLicenseResult.hbs @@ -1,29 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", - "data": [ - {{#each data}} - { - "mispId": "$IGNORE$", - "licenseKey": "$IGNORE$", - "validFromDate": "$IGNORE$", - "validToDate": "$IGNORE$" - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" } diff --git a/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/updateMispLicenseResult.hbs b/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/updateMispLicenseResult.hbs index bbad0f90a20..3e674c07f72 100644 --- a/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/updateMispLicenseResult.hbs +++ b/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/updateMispLicenseResult.hbs @@ -1,13 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "providerId": "{{providerId}}", - "licenseKey": "$IGNORE$", - "licenseKeyStatus": "{{licenseKeyStatus}}", - "licenseKeyExpiry": "$IGNORE$" - }, - "errors": "$IGNORE$" + "licenseKeyStatus": "{{licenseKeyStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs b/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs index 3e1176cbee1..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs +++ b/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs @@ -1,37 +1,2 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", - "data": [ - {{#each data}} - { - "id": "$IGNORE$", - "address": "$IGNORE$", - "contactNo": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": null, - "emailId": "$IGNORE$", - "isActive": "$IGNORE$", - "isDeleted": $IGNORE$, - "name": "$IGNORE$", - "policyGroupId": "$IGNORE$", - "certificateAlias": "$IGNORE$", - "partnerTypeCode": "$IGNORE$", - "approvalStatus": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "userId": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml index 089cf222cd9..174f91e5687 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml +++ b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml @@ -323,11 +323,7 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": $IGNORE$ - } - ] + }' Partner_SearchPartner_columnname_address_desc_sid: endPoint: /v1/partnermanager/partners/search @@ -356,11 +352,7 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": $IGNORE$ - } - ] + }' Partner_SearchPartner_with_invalid_value_containts: endPoint: /v1/partnermanager/partners/search diff --git a/automationtests/src/main/resources/partner/PrintPartner/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/PrintPartner/CreatePartner/createPartnerResult.hbs index 9e84194f547..bda15db3435 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/PrintPartner/CreatePartner/createPartnerResult.hbs @@ -1,10 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetailsResult.hbs b/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetailsResult.hbs index 77f800e3023..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetailsResult.hbs +++ b/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetailsResult.hbs @@ -1,8 +1,2 @@ { - "id": "mosip.partnermanagement.partners.retrieve", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PrintPartner/UpdatePrintPartner/UpdatePrintPartnerResult.hbs b/automationtests/src/main/resources/partner/PrintPartner/UpdatePrintPartner/UpdatePrintPartnerResult.hbs index dc6d7445e4a..bda15db3435 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/UpdatePrintPartner/UpdatePrintPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/PrintPartner/UpdatePrintPartner/UpdatePrintPartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml index 61cad77df9a..abade460cc3 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml @@ -9,5 +9,4 @@ UploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/PrintPartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/PrintPartner/UploadCert/uploadCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/PrintPartner/UploadCert/uploadCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PrintPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/PrintPartner/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/PrintPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult.hbs index 2c1371eef7c..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult.hbs @@ -1,25 +1,2 @@ { - "responsetime": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", - "data": [ - {{#each data}} - { - "id": "$IGNORE$", - "deviceProviderId": "$IGNORE$", - "deviceTypeCode": "$IGNORE$", - "deviceSubTypeCode": "$IGNORE$", - "make": "$IGNORE$", - "model": "$IGNORE$", - "partnerOrganizationName": "$IGNORE$", - "isActive": "$IGNORE$", - "approvalStatus": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceTypeResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceTypeResult.hbs index c1d7246f666..c31a048594b 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceTypeResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceTypeResult.hbs @@ -1,24 +1,12 @@ { - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "code": "$IGNORE$", - "deviceType": "$IGNORE$", - "name": "$IGNORE$", - "desciption": "$IGNORE$", - "isDeleted": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", "active": "{{active}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs index 4d4a6186d12..f5b21de0c2c 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs @@ -1,36 +1,11 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "id": "$IGNORE$", - "address": "$IGNORE$", - "contactNo": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "emailId": "$IGNORE$", - "isActive": {{isActive}}, - "isDeleted": "$IGNORE$", - "name": "$IGNORE$", - "policyGroupId": "$IGNORE$", - "certificateAlias": "$IGNORE$", - "partnerTypeCode": "$IGNORE$", - "approvalStatus": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "userId": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult.hbs index 9b5b328e648..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult.hbs @@ -1,33 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", - "data": [ - {{#each data}} - { - "label": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "isActive": "$IGNORE$", - "isDeleted": "$IGNORE$", - "policyId": "$IGNORE$", - "policyName": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "validFromDatetime": "$IGNORE$", - "validToDatetime": "$IGNORE$", - "partnerId": "$IGNORE$", - "partnerName": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml index 341fe601577..754df577004 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml @@ -12,11 +12,6 @@ SearchPartnerApiRequestKey: "version": "v1" }' output: '{ - "data": [ - { - "apikeyRequestId": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiRequestKey_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search @@ -59,11 +54,6 @@ SearchPartnerApiRequestKey: "version": "v1" }' output: '{ - "data": [ - { - "apikeyRequestId": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiRequestKey_Only_PaginationCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search @@ -78,11 +68,6 @@ SearchPartnerApiRequestKey: "version": "v1" }' output: '{ - "data": [ - { - "apikeyRequestId": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiRequestKey_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/apikey/request/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs index d50472999a7..c3e73352876 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs @@ -1,31 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "apikeyRequestId": "{{apikeyRequestId}}", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": null, - "isDeleted": "$IGNORE$", - "policyId": "$IGNORE$", - "requestDatetimes": "$IGNORE$", - "requestDetail": "$IGNORE$", - "statusCode": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "partnerId": "$IGNORE$" + "apikeyRequestId": "{{apikeyRequestId}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml index 1e7ee269bb2..ffa718641bb 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml @@ -306,7 +306,6 @@ createSearchPartnerType: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPartnerType_with_invalid_value_startswith: endPoint: /v1/partnermanager/partners/partnertype/search @@ -334,7 +333,6 @@ createSearchPartnerType: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPartnerType_with_invalid_columnName: endPoint: /v1/partnermanager/partners/partnertype/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerTypeResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerTypeResult.hbs index 6ce7afa1cf2..0d69ee0dc7a 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerTypeResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerTypeResult.hbs @@ -1,26 +1,12 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "code": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "isActive": {{isActive}}, - "isDeleted": "$IGNORE$", - "partnerDescription": "$IGNORE$", - "isPolicyRequired": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml index 66bb58955f0..075b647992a 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml @@ -13,13 +13,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "IGNORE$" - } - ] }' Partner_SearchPolicy_Only_FilterCriteria_Smoke: endPoint: /partnermanagement/v1/policies/policy/search @@ -70,13 +63,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "$IGNORE$" - } - ] }' Partner_SearchPolicy_Only_PaginationCriteria_Smoke: endPoint: /partnermanagement/v1/policies/policy/search @@ -92,13 +78,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "$IGNORE$" - } - ] }' Partner_SearchPolicy_type_contains_Smoke_asc_sid: endPoint: /partnermanagement/v1/policies/policy/search @@ -337,7 +316,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_invalid_value_equals: endPoint: /partnermanagement/v1/policies/policy/search @@ -366,7 +344,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_invalid_value_startswith: endPoint: /partnermanagement/v1/policies/policy/search @@ -395,7 +372,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_invalid_columnName: endPoint: /partnermanagement/v1/policies/policy/search @@ -458,7 +434,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_missing_type: endPoint: /partnermanagement/v1/policies/policy/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicyResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicyResult.hbs index 28653a62e5b..0198e2e47bb 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicyResult.hbs @@ -1,35 +1,13 @@ { - "id": null, - "version": null, - "responsetime": "$TIMESTAMP$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "id": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "descr": "$IGNORE$", - "isActive": "$IGNORE$", - "isDeleted": "$IGNORE$", - "name": "$IGNORE$", - "policyFileId": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "validFromDate": "$IGNORE$", - "validToDate": "$IGNORE$", "version": "{{version}}", - "policyType": "$IGNORE$", - "schema": "{{schema}}", - "policyGroup": "$IGNORE$" + "schema": "{{schema}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml index 88bb90cd308..9b5c591008b 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml @@ -98,7 +98,6 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "$IGNORE$" }' Partner_SearchPolicyGroup_type_contains_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs index d5b6c6593e4..0d69ee0dc7a 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs @@ -1,29 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "id": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "descr": "$IGNORE$", - "isActive": {{isActive}}, - "isDeleted": $IGNORE$, - "name": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "userId": "$IGNORE$" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDeviceResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDeviceResult.hbs index ded783b6c82..c31a048594b 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDeviceResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDeviceResult.hbs @@ -1,39 +1,12 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "code": "$IGNORE$", - "statusCode": "$IGNORE$", - "deviceId": "$IGNORE$", - "deviceSubId": "$IGNORE$", - "digitalId": "$IGNORE$", - "serialNo": "$IGNORE$", - "deviceDetailId": "$IGNORE$", - "purpose": "$IGNORE$", - "firmware": "$IGNORE$", - "expiryDate": "$IGNORE$", - "certificationLevel": "$IGNORE$", - "foundationalTPId": "$IGNORE$", - "hotlisted": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "active": "{{active}}", - "deleted": "$IGNORE$" + "active": "{{active}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml index f2676b38d2e..98670f41b2f 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml @@ -11,11 +11,6 @@ createSearchSecureBiometric: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "providerId": "$IGNORE$" - } - ] }' Partner_SearchSecureBiometric_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search @@ -60,11 +55,6 @@ createSearchSecureBiometric: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "providerId": "$IGNORE$" - } - ] }' Partner_SearchSecureBiometric_Only_PaginationCriteria_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search @@ -78,11 +68,6 @@ createSearchSecureBiometric: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "providerId": "$IGNORE$" - } - ] }' Partner_SearchSecureBiometric_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/securebiometricinterface/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult.hbs index b75282240d4..0a3559744ef 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult.hbs @@ -1,32 +1,11 @@ { - "responsetime": "$IGNORE$", - "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "id": "$IGNORE$", - "swBinaryHash": "$IGNORE$", - "swVersion": "$IGNORE$", - "deviceDetailId": null, - "swCreateDateTime": "$IGNORE$", - "swExpiryDateTime": "$IGNORE$", - "isActive": "$IGNORE$", - "approvalStatus": "$IGNORE$", - "providerId": "{{providerId}}", - "partnerOrganizationName": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": null, - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "deleted": "$IGNORE$" + "providerId": "{{providerId}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs b/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs index e1a98ec444a..ba212b70ab8 100644 --- a/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/updatePolicyGroupForPartnerResult.hbs b/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/updatePolicyGroupForPartnerResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/updatePolicyGroupForPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/updatePolicyGroupForPartnerResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/VerifyPartnersEmail/verifyPartnersEmailResult.hbs b/automationtests/src/main/resources/partner/VerifyPartnersEmail/verifyPartnersEmailResult.hbs index afa32d34409..b2b5740b608 100644 --- a/automationtests/src/main/resources/partner/VerifyPartnersEmail/verifyPartnersEmailResult.hbs +++ b/automationtests/src/main/resources/partner/VerifyPartnersEmail/verifyPartnersEmailResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "emailExists": "{{emailExists}}", - "policyRequiredPartnerTypes": "$IGNORE$" - }, - "errors": "$IGNORE$" + "emailExists": "{{emailExists}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs b/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs index 2bbd42954cd..08de5cbd505 100644 --- a/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "apiRequestId": "$IGNORE$", - "message": "{{message}}", - "apikeyId": "$IGNORE$" - }, - "errors": "$IGNORE$" + "message": "{{message}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs b/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs index d0e93ce1928..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs @@ -1,7 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml b/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml index c7e0317eba9..f57769b004d 100644 --- a/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml +++ b/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml @@ -108,8 +108,7 @@ createPartnerSelfRegistration: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "$IGNORE$" + "errorCode": "PMS_COR_001" } ] }' @@ -159,8 +158,7 @@ createPartnerSelfRegistration: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "$IGNORE$" + "errorCode": "PMS_COR_001" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/authPartner/CreatePartner/createPartnerResult.hbs index 25766a41cd9..95dc2a1a1f6 100644 --- a/automationtests/src/main/resources/partner/authPartner/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/CreatePartner/createPartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/GetCertificate/getCertResult.hbs b/automationtests/src/main/resources/partner/authPartner/GetCertificate/getCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/GetCertificate/getCertResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/GetCertificate/getCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/GetPartner/getPartnerResult.hbs b/automationtests/src/main/resources/partner/authPartner/GetPartner/getPartnerResult.hbs index 9b02105749d..ae9c778decb 100644 --- a/automationtests/src/main/resources/partner/authPartner/GetPartner/getPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/GetPartner/getPartnerResult.hbs @@ -1,18 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", + "response": { - "partnerID": "{{partnerID}}", - "status": "$IGNORE$", - "organizationName": "$IGNORE$", - "contactNumber": "$IGNORE$", - "emailId": "$IGNORE$", - "address": "$IGNORE$", - "partnerType": "$IGNORE$", - "policyGroup": "$IGNORE$", - "isActive": "$IGNORE$" - }, - "errors": "$IGNORE$" + "partnerID": "{{partnerID}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs b/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml index 823295cfe4b..30968b1f1bf 100644 --- a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml +++ b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml @@ -11,7 +11,6 @@ RequestAPIKeyForAuthPartner: "requesttime": "$TIMESTAMP$" }' output: '{ - "mappingkey": "$IGNORE$", "message": "Policy mapping request submitted successfully." }' Partner_SubmitPartnerApiKeyRequest_Approval_All_Valid_Smoke_sid: @@ -26,7 +25,6 @@ RequestAPIKeyForAuthPartner: "requesttime": "$TIMESTAMP$" }' output: '{ - "mappingkey": "$IGNORE$", "message": "Policy mapping request submitted successfully." }' Partner_SubmitPartnerApiKeyRequest_invalid_policyName: @@ -44,7 +42,6 @@ RequestAPIKeyForAuthPartner: "errors": [ { "errorCode": "PMS_PRT_098", - "message": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs index f28509c6269..abcbd48dff4 100644 --- a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "mappingkey": "$IGNORE$", "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/UpdatePartner/updatePartnerResult.hbs b/automationtests/src/main/resources/partner/authPartner/UpdatePartner/updatePartnerResult.hbs index 25766a41cd9..95dc2a1a1f6 100644 --- a/automationtests/src/main/resources/partner/authPartner/UpdatePartner/updatePartnerResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/UpdatePartner/updatePartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml index 35fd39d3056..65b448d6ad0 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml @@ -11,8 +11,7 @@ uploadPartnerCert: output: ' { "errors": [ { - "errorCode": "PMS_COR_001", - "message": "$IGNORE$" + "errorCode": "PMS_COR_001" } ] }' @@ -28,8 +27,7 @@ uploadPartnerCert: output: ' { "errors": [ { - "errorCode": "KER-KMS-013", - "message": "$IGNORE$" + "errorCode": "KER-KMS-013" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/authPartner/UploadCert/uploadCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/UploadCert/uploadCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml index d93c054f067..63e0d635254 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml +++ b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml @@ -23,8 +23,7 @@ uploadCACert: output: ' { "errors": [ { - "errorCode": "KER-PCM-003", - "message": "$IGNORE$" + "errorCode": "KER-PCM-003" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs index 2bbd42954cd..08de5cbd505 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "apiRequestId": "$IGNORE$", - "message": "{{message}}", - "apikeyId": "$IGNORE$" - }, - "errors": "$IGNORE$" + "message": "{{message}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs index 478536246fc..9f8a4a538a5 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{message}}", - "errors": "$IGNORE$" + "response": "{{message}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/CreatePartner/createPartnerResult.hbs index 25766a41cd9..95dc2a1a1f6 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/CreatePartner/createPartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml index ce3062b9fb8..766895d3eeb 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml @@ -10,5 +10,4 @@ getPartnerCert: "partnerId": "MOVP" }' output: ' { - "errors": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/getCertResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/getCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/getCertResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/getCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/GetPartner/getPartnerResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/GetPartner/getPartnerResult.hbs index 9b02105749d..bd204788b5a 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/GetPartner/getPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/GetPartner/getPartnerResult.hbs @@ -1,18 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "partnerID": "{{partnerID}}", - "status": "$IGNORE$", - "organizationName": "$IGNORE$", - "contactNumber": "$IGNORE$", - "emailId": "$IGNORE$", - "address": "$IGNORE$", - "partnerType": "$IGNORE$", - "policyGroup": "$IGNORE$", - "isActive": "$IGNORE$" - }, - "errors": "$IGNORE$" + "partnerID": "{{partnerID}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml index 424c6687279..42d6c2cc59a 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml @@ -11,7 +11,6 @@ RequestAPIKeyCredentialPartner: "requesttime": "$TIMESTAMP$" }' output: ' { - "mappingkey": "$IGNORE$", "message": "Policy mapping request submitted successfully." }' Partner_CredPartnerApiKeyRequest_Rejection_All_Valid_Smoke_sid: @@ -26,6 +25,5 @@ RequestAPIKeyCredentialPartner: "requesttime": "$TIMESTAMP$" }' output: ' { - "mappingkey": "$IGNORE$", "message": "Policy mapping request submitted successfully." }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs index f28509c6269..1969a7e3c0e 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs @@ -1,11 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "mappingkey": "$IGNORE$", "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs index f175b91d60a..51a54105dc5 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs @@ -1,12 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs index 3e7903a135c..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs @@ -1,8 +1,3 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": "{{response}}", - "errors": [] + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/RemoveMapDeviceWithSBI/removeMapDeviceWithSBIResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/RemoveMapDeviceWithSBI/removeMapDeviceWithSBIResult.hbs index 3e7903a135c..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/RemoveMapDeviceWithSBI/removeMapDeviceWithSBIResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/RemoveMapDeviceWithSBI/removeMapDeviceWithSBIResult.hbs @@ -1,8 +1,3 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": "{{response}}", - "errors": [] + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml index 4099c2114f5..e66d67be424 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml @@ -14,7 +14,6 @@ createSaveSecureBiometricInterface: "providerId": "Tech-123" }' output: '{ - "id": "$IGNORE$" }' Partner_SaveSecureBiometricInterface_Valid_Smoke_sid: endPoint: /v1/partnermanager/securebiometricinterface @@ -31,7 +30,6 @@ createSaveSecureBiometricInterface: "providerId": "Tech-123" }' output: '{ - "id": "$IGNORE$" }' Partner_SaveSecureBiometricInterface_Missing_InputParameter_swVersion: endPoint: /v1/partnermanager/securebiometricinterface diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult.hbs index acb7529e337..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult.hbs @@ -1,10 +1,2 @@ { - "id": null, - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "id": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/deregistration/deRegisterDeviceResult.hbs b/automationtests/src/main/resources/partner/device/deregistration/deRegisterDeviceResult.hbs index 2383f2d8255..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/deregistration/deRegisterDeviceResult.hbs +++ b/automationtests/src/main/resources/partner/device/deregistration/deRegisterDeviceResult.hbs @@ -1,8 +1,2 @@ { - "id": null, - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs index 5b69b118b1e..b8eed36f548 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/create/createFTPChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/create/createFTPChipDetailResult.hbs index 5b69b118b1e..b8eed36f548 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/create/createFTPChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/create/createFTPChipDetailResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml index d90f9683c28..0802e14ae24 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml @@ -9,5 +9,4 @@ GetFTPChipDetail: "ftpChipDetailId": "$ID:CreateFTPChipDetail_All_Valid_Smoke_sid_id$" }' output: '{ - "id": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/get/getFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/get/getFtpChipDetailResult.hbs index 6ae1d889284..0af704eda69 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/get/getFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/get/getFtpChipDetailResult.hbs @@ -1,8 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs index 1b686141c03..e84accca3de 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs index 5b69b118b1e..b8eed36f548 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "id": "{{id}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml index 1e22e67d831..f8518deaf5c 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml @@ -13,7 +13,6 @@ UploadCertificateOfFtpChip: "partnerDomain": "DEVICE" }' output: ' { - "certificateId": "$IGNORE$" }' Partner_UploadCertificate_InValid_ftpProviderId: endPoint: /v1/partnermanager/ftpchipdetail/uploadcertificate diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/uploadcertificateResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/uploadcertificateResult.hbs index 4a839cc5779..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/uploadcertificateResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/uploadcertificateResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateData": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml index a9aa8cc875a..acffac6a4c7 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml @@ -57,7 +57,6 @@ createServiceToSaveDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$" }' Partner_ServiceToSaveDeviceDetail_sameTypeSubType_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail @@ -77,7 +76,6 @@ createServiceToSaveDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$" }' Partner_ServiceToSaveDeviceDetail_AlreadyExists_Invalid: endPoint: /v1/partnermanager/devicedetail diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs index 8a8dbd0ceae..3d6bd8ac86b 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs @@ -1,10 +1,5 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { "id": "{{id}}" - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs index c6320c96352..eb8d6fea9a8 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs @@ -1,8 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "{{response}}", - "errors": "$IGNORE$" + "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs index 34c024fa5fc..3d6bd8ac86b 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs @@ -1,7 +1,5 @@ { - "responsetime": "$IGNORE$", "response": { "id": "{{id}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/registration/registereDeviceResult.hbs b/automationtests/src/main/resources/partner/device/registration/registereDeviceResult.hbs index e9a773b9516..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/registration/registereDeviceResult.hbs +++ b/automationtests/src/main/resources/partner/device/registration/registereDeviceResult.hbs @@ -1,8 +1,2 @@ { - "id": "io.mosip.deviceregister", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/devicePartner/CreatePartner/createPartnerResult.hbs index 25766a41cd9..bf2e59dcd9e 100644 --- a/automationtests/src/main/resources/partner/devicePartner/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/CreatePartner/createPartnerResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "partnerId": "{{partnerId}}", - "status": "{{status}}" - }, - "errors": "$IGNORE$" + "partnerId": "{{partnerId}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml index 613708be26e..1054917cda4 100644 --- a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml @@ -10,7 +10,6 @@ GetPartnerCert: "partnerId": "DPP" }' output: ' { - "errors": "$IGNORE$" }' Partner_GetPartnerCert_invalid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/certificate diff --git a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/getCertResult.hbs b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/getCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/getCertResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/getCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/GetPartner/getPartnerResult.hbs b/automationtests/src/main/resources/partner/devicePartner/GetPartner/getPartnerResult.hbs index 9b02105749d..bd204788b5a 100644 --- a/automationtests/src/main/resources/partner/devicePartner/GetPartner/getPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/GetPartner/getPartnerResult.hbs @@ -1,18 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "partnerID": "{{partnerID}}", - "status": "$IGNORE$", - "organizationName": "$IGNORE$", - "contactNumber": "$IGNORE$", - "emailId": "$IGNORE$", - "address": "$IGNORE$", - "partnerType": "$IGNORE$", - "policyGroup": "$IGNORE$", - "isActive": "$IGNORE$" - }, - "errors": "$IGNORE$" + "partnerID": "{{partnerID}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs index f175b91d60a..51a54105dc5 100644 --- a/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs @@ -1,12 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/error.hbs b/automationtests/src/main/resources/partner/error.hbs index 76ee450326e..f4bcb6bee67 100644 --- a/automationtests/src/main/resources/partner/error.hbs +++ b/automationtests/src/main/resources/partner/error.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "timestamp": "$IGNORE$", - "status": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "message": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/partner/mispPartner/CreatePartner/createPartnerResult.hbs b/automationtests/src/main/resources/partner/mispPartner/CreatePartner/createPartnerResult.hbs index 25766a41cd9..95dc2a1a1f6 100644 --- a/automationtests/src/main/resources/partner/mispPartner/CreatePartner/createPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/mispPartner/CreatePartner/createPartnerResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml index 3c7d8d39589..64d3427fa8e 100644 --- a/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml @@ -10,5 +10,4 @@ getPartnerCert: "partnerId": "MISP" }' output: ' { - "errors": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/mispPartner/GetCertificate/getCertResult.hbs b/automationtests/src/main/resources/partner/mispPartner/GetCertificate/getCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/mispPartner/GetCertificate/getCertResult.hbs +++ b/automationtests/src/main/resources/partner/mispPartner/GetCertificate/getCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/mispPartner/GetPartner/getPartnerResult.hbs b/automationtests/src/main/resources/partner/mispPartner/GetPartner/getPartnerResult.hbs index 9b02105749d..bd204788b5a 100644 --- a/automationtests/src/main/resources/partner/mispPartner/GetPartner/getPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/mispPartner/GetPartner/getPartnerResult.hbs @@ -1,18 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "partnerID": "{{partnerID}}", - "status": "$IGNORE$", - "organizationName": "$IGNORE$", - "contactNumber": "$IGNORE$", - "emailId": "$IGNORE$", - "address": "$IGNORE$", - "partnerType": "$IGNORE$", - "policyGroup": "$IGNORE$", - "isActive": "$IGNORE$" - }, - "errors": "$IGNORE$" + "partnerID": "{{partnerID}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/mispPartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/mispPartner/UploadCert/uploadCertResult.hbs index f175b91d60a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/mispPartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/mispPartner/UploadCert/uploadCertResult.hbs @@ -1,12 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "signedCertificateData": "$IGNORE$", - "certificateId": "$IGNORE$", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs index 254f27a1975..8b1342210ff 100644 --- a/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "timestamp": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/defineDataSharePolicyResult.hbs b/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/defineDataSharePolicyResult.hbs index 8d602b86e84..b57a63be056 100644 --- a/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/defineDataSharePolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/defineDataSharePolicyResult.hbs @@ -1,16 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", - "name": "{{name}}", - "desc": "{{desc}}", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + "is_Active": {{is_Active}} + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/DefinePolicy/definePolicyResult.hbs b/automationtests/src/main/resources/partner/policy/DefinePolicy/definePolicyResult.hbs index 8d602b86e84..23bf0f37163 100644 --- a/automationtests/src/main/resources/partner/policy/DefinePolicy/definePolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/DefinePolicy/definePolicyResult.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "name": "{{name}}", "desc": "{{desc}}", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + "is_Active": {{is_Active}} + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/DefinePolicyGroup.yml b/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/DefinePolicyGroup.yml index a75a387e72c..450409e077f 100644 --- a/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/DefinePolicyGroup.yml +++ b/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/DefinePolicyGroup.yml @@ -11,7 +11,6 @@ definePolicyGroup: "requesttime": "$TIMESTAMP$" }' output: ' { - "id": "$IGNORE$", "name": "mosip policy group", "desc": "desc mosip policy group", "is_Active": true @@ -28,7 +27,6 @@ definePolicyGroup: "requesttime": "$TIMESTAMP$" }' output: ' { - "id": "$IGNORE$", "name": "mosip policy role testing groupp", "desc": "desc mosip policy group 9983", "is_Active": true @@ -64,7 +62,6 @@ definePolicyGroup: "requesttime": "$TIMESTAMP$" }' output: ' { - "id": "$IGNORE$", "name": "mosip policy group2", "desc": "desc mosip policy group2", "is_Active": true @@ -100,7 +97,6 @@ definePolicyGroup: "requesttime": "$TIMESTAMP$" }' output: ' { - "id": "$IGNORE$", "name": "update_policy_group", "desc": "desc update policy group", "is_Active": true diff --git a/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs b/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs index c154e311425..d65415308da 100644 --- a/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs @@ -1,17 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "name": "{{name}}", "desc": "{{desc}}", "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs index 4e27766ce6c..79c7c73cf29 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs @@ -1,32 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "policyGroupId": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "policyGroupDesc": "{{policyGroupDesc}}", "policyGroupStatus": {{policyGroupStatus}}, - "policyGroup_cr_by": "$IGNORE$", - "policyGroup_cr_dtimes": "$IGNORE$", - "policyGroup_up_by": "$IGNORE$", - "policyGroup_upd_dtimes": "$IGNORE$", - "policyId": "$IGNORE$", "policyName": "{{policyName}}", "policyDesc": "{{policyDesc}}", - "policyType": "$IGNORE$", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", - "is_Active": "$IGNORE$", - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", - "policies": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/GetPolicyGroup/getPolicyGroupResult.hbs b/automationtests/src/main/resources/partner/policy/GetPolicyGroup/getPolicyGroupResult.hbs index cf4bc25857e..77f13766459 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicyGroup/getPolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/policy/GetPolicyGroup/getPolicyGroupResult.hbs @@ -1,20 +1,9 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "policyGroup" :{ - "id": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", "desc": "{{desc}}", "isActive": {{isActive}}, - "isDeleted": "$IGNORE$", - "name": "{{name}}", - "userId": "$IGNORE$" - }, - "policies" :"$IGNORE$" - }, - "errors": "$IGNORE$" + "name": "{{name}}" + } + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/publishDataSharePolicyResult.hbs b/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/publishDataSharePolicyResult.hbs index abf9bb79a21..5e3f3be2e52 100644 --- a/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/publishDataSharePolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/publishDataSharePolicyResult.hbs @@ -1,35 +1,15 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "policyGroupId": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "policyGroupDesc": "{{policyGroupDesc}}", "policyGroupStatus": {{policyGroupStatus}}, - "policyGroup_cr_by": "$IGNORE$", - "policyGroup_cr_dtimes": "$IGNORE$", - "policyGroup_up_by": "$IGNORE$", - "policyGroup_upd_dtimes": "$IGNORE$", - "policyId": "$IGNORE$", "policyName": "{{policyName}}", "policyDesc": "{{policyDesc}}", "policyType": "{{policyType}}", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", "policies": { "shareableAttributes": [{ "attributeName": "{{attributeName}}", - "group": "$IGNORE$", "source": [{ "attribute": "registration-client\/NEW\/individualBiometrics", "filter": [{ @@ -58,6 +38,5 @@ "source": "Packet Manager" } } - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/PublishPolicy/publishPolicyResult.hbs b/automationtests/src/main/resources/partner/policy/PublishPolicy/publishPolicyResult.hbs index 14a4a02f493..06e90800ca5 100644 --- a/automationtests/src/main/resources/partner/policy/PublishPolicy/publishPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/PublishPolicy/publishPolicyResult.hbs @@ -1,31 +1,12 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "policyGroupId": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "policyGroupDesc": "{{policyGroupDesc}}", "policyGroupStatus": {{policyGroupStatus}}, - "policyGroup_cr_by": "$IGNORE$", - "policyGroup_cr_dtimes": "$IGNORE$", - "policyGroup_up_by": "$IGNORE$", - "policyGroup_upd_dtimes": "$IGNORE$", - "policyId": "$IGNORE$", "policyName": "{{policyName}}", "policyDesc": "{{policyDesc}}", "policyType": "{{policyType}}", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", "policies": { "allowedAuthTypes": [ { @@ -41,6 +22,5 @@ ], "authTokenType": "{{authTokenType}}" } - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index a88b93db92f..ffe603ba382 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -122,8 +122,7 @@ createSearchPolicy: "data": [ { "version": "1.0", - "policyType": "DataShare", - "schema": "$IGNORE$" + "policyType": "DataShare" } ] }' @@ -157,8 +156,7 @@ createSearchPolicy: "data": [ { "version": "1.0", - "policyType": "DataShare", - "schema": "$IGNORE$" + "policyType": "DataShare" } ] }' @@ -297,8 +295,7 @@ createSearchPolicy: "data": [ { "version": "1.0", - "policyType": "DataShare", - "schema": "$IGNORE$" + "policyType": "DataShare" } ] }' @@ -360,7 +357,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_invalid_value_startswith: endPoint: /v1/policymanager/policies/search @@ -452,7 +448,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_missing_type: endPoint: /v1/policymanager/policies/search diff --git a/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs b/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs index e5e063963f8..92ba38bc16c 100644 --- a/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs @@ -1,18 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "policyGroupName": "{{policyGroupName}}", "name": "{{name}}", "desc": "{{desc}}", "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/UpdatePolicyGroup/updatePolicyGroupResult.hbs b/automationtests/src/main/resources/partner/policy/UpdatePolicyGroup/updatePolicyGroupResult.hbs index c154e311425..101febb627e 100644 --- a/automationtests/src/main/resources/partner/policy/UpdatePolicyGroup/updatePolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/policy/UpdatePolicyGroup/updatePolicyGroupResult.hbs @@ -1,17 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "id": "$IGNORE$", "name": "{{name}}", "desc": "{{desc}}", - "is_Active": {{is_Active}}, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$" - }, - "errors": "$IGNORE$" + "is_Active": {{is_Active}} + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/UpdatePolicyStatus/updatePolicyStatusResult.hbs b/automationtests/src/main/resources/partner/policy/UpdatePolicyStatus/updatePolicyStatusResult.hbs index 89bdad319e1..59d1e091a29 100644 --- a/automationtests/src/main/resources/partner/policy/UpdatePolicyStatus/updatePolicyStatusResult.hbs +++ b/automationtests/src/main/resources/partner/policy/UpdatePolicyStatus/updatePolicyStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "message": "{{message}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file From 34278bfbc0433fc696835d6576a68e23964a59a8 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 13:11:22 +0530 Subject: [PATCH 076/204] MOSIP-29083 --- .../apirig/testscripts/EsignetBioAuth.java | 5 +++- .../esignet/BioAuthIdp/BioAuthIdp.yml | 24 +++++++++++++++++++ .../esignet/BioAuthIdp/bioAuthResult.hbs | 8 +------ 3 files changed, 29 insertions(+), 8 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java index 195e99f7c54..b252a2c9709 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java @@ -185,7 +185,10 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); - } catch (Exception e) { + } catch (SkipException e) { + throw new SkipException(e.getMessage()); + } + catch (Exception e) { logger.error(e.getMessage()); } diff --git a/automationtests/src/main/resources/esignet/BioAuthIdp/BioAuthIdp.yml b/automationtests/src/main/resources/esignet/BioAuthIdp/BioAuthIdp.yml index 3eafa0a3ae5..5f3fd7ff892 100644 --- a/automationtests/src/main/resources/esignet/BioAuthIdp/BioAuthIdp.yml +++ b/automationtests/src/main/resources/esignet/BioAuthIdp/BioAuthIdp.yml @@ -3,6 +3,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -42,6 +43,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -80,6 +82,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -118,6 +121,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -156,6 +160,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -194,6 +199,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -232,6 +238,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -270,6 +277,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -308,6 +316,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -346,6 +355,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -384,6 +394,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -422,6 +433,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -460,6 +472,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -498,6 +511,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -536,6 +550,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -574,6 +589,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -612,6 +628,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -650,6 +667,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -688,6 +706,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -726,6 +745,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -764,6 +784,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -802,6 +823,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -840,6 +862,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult @@ -878,6 +901,7 @@ BioAuth: endPoint: /v1/esignet/authorization/authenticate role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/BioAuthIdp/bioAuth outputTemplate: esignet/BioAuthIdp/bioAuthResult diff --git a/automationtests/src/main/resources/esignet/BioAuthIdp/bioAuthResult.hbs b/automationtests/src/main/resources/esignet/BioAuthIdp/bioAuthResult.hbs index cb77a226020..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/esignet/BioAuthIdp/bioAuthResult.hbs +++ b/automationtests/src/main/resources/esignet/BioAuthIdp/bioAuthResult.hbs @@ -1,7 +1 @@ -{ - "responseTime": "$IGNORE$", - "response": { - "transactionId": "{{transactionId}}" - }, - "errors": [] -} \ No newline at end of file +{} \ No newline at end of file From bbb8a8b2e7ce02e9026505a69ad38ca03c6742c7 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 13:22:44 +0530 Subject: [PATCH 077/204] MOSIP-29088 --- .../testrig/apirig/service/BaseTestCase.java | 4 +++- .../apirig/testrunner/ExtractResource.java | 18 +++++++++--------- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index c71e676064b..ad7afc44964 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -238,7 +238,9 @@ public static void suiteSetup() { String[] modulesSpecified = System.getProperty("modules").split(","); listOfModules = new ArrayList(Arrays.asList(modulesSpecified)); - AuthTestsUtil.removeOldMosipTempTestResource(); + if (!MosipTestRunner.checkRunType().equalsIgnoreCase("JAR")) { + AuthTestsUtil.removeOldMosipTempTestResource(); + } if (listOfModules.contains("auth")) { setReportName("auth"); BaseTestCase.currentModule = "auth"; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java index a489494ff22..cc8852546b5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java @@ -14,16 +14,16 @@ public class ExtractResource { private static final Logger LOGGER = Logger.getLogger(ExtractResource.class); public static void extractResourceFromJar() { - getListOfFilesFromJarAndCopyToExternalResource("preReg/"); +// getListOfFilesFromJarAndCopyToExternalResource("preReg/"); getListOfFilesFromJarAndCopyToExternalResource("config/"); - getListOfFilesFromJarAndCopyToExternalResource("masterdata/"); +// getListOfFilesFromJarAndCopyToExternalResource("masterdata/"); getListOfFilesFromJarAndCopyToExternalResource("syncdata/"); - getListOfFilesFromJarAndCopyToExternalResource("ida/"); +// getListOfFilesFromJarAndCopyToExternalResource("ida/"); getListOfFilesFromJarAndCopyToExternalResource("kernel/"); - getListOfFilesFromJarAndCopyToExternalResource("regProc/"); - getListOfFilesFromJarAndCopyToExternalResource("idRepository/"); - getListOfFilesFromJarAndCopyToExternalResource("resident/"); - getListOfFilesFromJarAndCopyToExternalResource("partner/"); +// getListOfFilesFromJarAndCopyToExternalResource("regProc/"); +// getListOfFilesFromJarAndCopyToExternalResource("idRepository/"); +// getListOfFilesFromJarAndCopyToExternalResource("resident/"); +// getListOfFilesFromJarAndCopyToExternalResource("partner/"); getListOfFilesFromJarAndCopyToExternalResource("customize-emailable-report-template.html"); getListOfFilesFromJarAndCopyToExternalResource("testngapi.xml"); getListOfFilesFromJarAndCopyToExternalResource("metadata.xml"); @@ -32,8 +32,8 @@ public static void extractResourceFromJar() { getListOfFilesFromJarAndCopyToExternalResource("spring.properties"); getListOfFilesFromJarAndCopyToExternalResource("validations.properties"); getListOfFilesFromJarAndCopyToExternalResource("dbFiles/"); - getListOfFilesFromJarAndCopyToExternalResource("mobileId/"); - getListOfFilesFromJarAndCopyToExternalResource("esignet/"); +// getListOfFilesFromJarAndCopyToExternalResource("mobileId/"); +// getListOfFilesFromJarAndCopyToExternalResource("esignet/"); } public static void getListOfFilesFromJarAndCopyToExternalResource(String key) { From 02b8970664dd0feac4f46231f09c9f1c81eb07a0 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 13:27:10 +0530 Subject: [PATCH 078/204] MOSIP-29088 --- .../testrig/apirig/testrunner/ExtractResource.java | 11 +---------- .../testrig/apirig/testrunner/MosipTestRunner.java | 2 +- 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java index cc8852546b5..7b6580a570c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java @@ -13,17 +13,10 @@ public class ExtractResource { private static final Logger LOGGER = Logger.getLogger(ExtractResource.class); - public static void extractResourceFromJar() { -// getListOfFilesFromJarAndCopyToExternalResource("preReg/"); + public static void extractCommonResourceFromJar() { getListOfFilesFromJarAndCopyToExternalResource("config/"); -// getListOfFilesFromJarAndCopyToExternalResource("masterdata/"); getListOfFilesFromJarAndCopyToExternalResource("syncdata/"); -// getListOfFilesFromJarAndCopyToExternalResource("ida/"); getListOfFilesFromJarAndCopyToExternalResource("kernel/"); -// getListOfFilesFromJarAndCopyToExternalResource("regProc/"); -// getListOfFilesFromJarAndCopyToExternalResource("idRepository/"); -// getListOfFilesFromJarAndCopyToExternalResource("resident/"); -// getListOfFilesFromJarAndCopyToExternalResource("partner/"); getListOfFilesFromJarAndCopyToExternalResource("customize-emailable-report-template.html"); getListOfFilesFromJarAndCopyToExternalResource("testngapi.xml"); getListOfFilesFromJarAndCopyToExternalResource("metadata.xml"); @@ -32,8 +25,6 @@ public static void extractResourceFromJar() { getListOfFilesFromJarAndCopyToExternalResource("spring.properties"); getListOfFilesFromJarAndCopyToExternalResource("validations.properties"); getListOfFilesFromJarAndCopyToExternalResource("dbFiles/"); -// getListOfFilesFromJarAndCopyToExternalResource("mobileId/"); -// getListOfFilesFromJarAndCopyToExternalResource("esignet/"); } public static void getListOfFilesFromJarAndCopyToExternalResource(String key) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 9579cbcce41..983a79821fd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -67,7 +67,7 @@ public static void main(String[] arg) { if (checkRunType().equalsIgnoreCase("JAR")) { ExtractResource.removeOldMosipTestTestResource(); - ExtractResource.extractResourceFromJar(); + ExtractResource.extractCommonResourceFromJar(); } ConfigManager.init(); BaseTestCase.suiteSetup(); From d0e23306f1ac397c575456df1746c58a4aa94efc Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 15:58:35 +0530 Subject: [PATCH 079/204] MOSIP-29088 --- .../apirig/admin/fw/util/AdminTestUtil.java | 31 +++++++++++-------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index acb28dd52c6..baadfb22c51 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -110,6 +110,7 @@ import io.mosip.testrig.apirig.kernel.util.KeycloakUserManager; import io.mosip.testrig.apirig.kernel.util.Translator; import io.mosip.testrig.apirig.service.BaseTestCase; +import io.mosip.testrig.apirig.testrunner.ExtractResource; import io.mosip.testrig.apirig.testrunner.MockSMTPListener; import io.mosip.testrig.apirig.testrunner.MosipTestRunner; import io.restassured.RestAssured; @@ -2444,20 +2445,24 @@ public static void initiateSyncDataTest() { } public static void copymoduleSpecificAndConfigFile(String moduleName) { - File destination = null; - File source = null; - try { - destination = new File( - RunConfigUtil.getGlobalResourcePath() + "/" + RunConfigUtil.resourceFolderName); - source = new File(RunConfigUtil.getGlobalResourcePath() + "/" + moduleName); - FileUtils.copyDirectoryToDirectory(source, destination); - - source = new File(RunConfigUtil.getGlobalResourcePath() + "/config"); - FileUtils.copyDirectoryToDirectory(source, destination); - logger.info("Copied the test resource successfully for " + moduleName); - } catch (Exception e) { - logger.error("Exception occured while copying the file for : " + moduleName + " Error : " + e.getMessage()); + if (MosipTestRunner.checkRunType().equalsIgnoreCase("JAR")) { + ExtractResource.getListOfFilesFromJarAndCopyToExternalResource(moduleName + "/"); + } else { + try { + File destination = new File( + RunConfigUtil.getGlobalResourcePath() + "/" + RunConfigUtil.resourceFolderName); + File source = new File(RunConfigUtil.getGlobalResourcePath() + "/" + moduleName); + FileUtils.copyDirectoryToDirectory(source, destination); + + source = new File(RunConfigUtil.getGlobalResourcePath() + "/config"); + FileUtils.copyDirectoryToDirectory(source, destination); + logger.info("Copied the test resource successfully for " + moduleName); + } catch (Exception e) { + logger.error( + "Exception occured while copying the file for : " + moduleName + " Error : " + e.getMessage()); + } } + } public static void copyAdminTestResource() { From b92e16fef5e72d30d1f7bb6dcab3c05aff42a9f0 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 16:58:14 +0530 Subject: [PATCH 080/204] MOSIP-29088 --- .../io/mosip/testrig/apirig/testrunner/ExtractResource.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java index 7b6580a570c..b95c3e6c2b7 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java @@ -75,7 +75,7 @@ public static void closeZipInputStream(ZipInputStream zipInputStream) { */ private static boolean copyFilesFromJarToOutsideResource(String resourceFileParentPath, String resourceFileName) { try { - String resourceFileAbsolutePath = resourceFileParentPath + resourceFileName; + String resourceFileAbsolutePath = resourceFileParentPath + "MosipTemporaryTestResource/" + resourceFileName; File destinationFile = new File(resourceFileAbsolutePath); LOGGER.info("resourceFile : " + MosipTestRunner.jarUrl + "destinationFile : " + resourceFileAbsolutePath); org.apache.commons.io.FileUtils.copyInputStreamToFile(MosipTestRunner.class.getResourceAsStream("/" + resourceFileName), destinationFile); From 977ad13692b7f7719a8c2a770901c2d1b703d2a2 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 17:08:31 +0530 Subject: [PATCH 081/204] remove authdemo service from push trigger yml --- .github/workflows/push_trigger.yml | 126 ++++++++++++++--------------- 1 file changed, 63 insertions(+), 63 deletions(-) diff --git a/.github/workflows/push_trigger.yml b/.github/workflows/push_trigger.yml index 5a65b60010a..94b1c7c0518 100644 --- a/.github/workflows/push_trigger.yml +++ b/.github/workflows/push_trigger.yml @@ -12,74 +12,74 @@ on: - 115_compatible_Test jobs: - build-authentication-demo-service: - runs-on: ubuntu-latest - env: - NAMESPACE: ${{ secrets.dev_namespace_docker_hub }} - SERVICE_NAME: authentication-demo-service - SERVICE_LOCATION: authentication-demo-service + # build-authentication-demo-service: + # runs-on: ubuntu-latest + # env: + # NAMESPACE: ${{ secrets.dev_namespace_docker_hub }} + # SERVICE_NAME: authentication-demo-service + # SERVICE_LOCATION: authentication-demo-service - steps: - - uses: actions/checkout@v2 - - name: Set up JDK 11 - uses: actions/setup-java@v1 - with: - ref: ${{ github.ref }} - java-version: 11 - server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml - settings-path: ${{ github.workspace }} # location for the settings.xml file + # steps: + # - uses: actions/checkout@v2 + # - name: Set up JDK 11 + # uses: actions/setup-java@v1 + # with: + # ref: ${{ github.ref }} + # java-version: 11 + # server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml + # settings-path: ${{ github.workspace }} # location for the settings.xml file - - name: Setup branch and env - run: | - # Strip git ref prefix from version - echo "BRANCH_NAME=$(echo ${{ github.ref }} | sed -e 's,.*/\(.*\),\1,')" >> $GITHUB_ENV - echo "GPG_TTY=$(tty)" >> $GITHUB_ENV - - uses: actions/cache@v1 - with: - path: ~/.m2/repository - key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} - restore-keys: | - ${{ runner.os }}-maven-${{ env.BRANCH_NAME }} - - name: Setup the settings file for ossrh server - run: echo " ossrh ${{secrets.ossrh_user}} ${{secrets.ossrh_secret}} ossrh true gpg2 ${{secrets.gpg_secret}} allow-snapshots true snapshots-repo https://oss.sonatype.org/content/repositories/snapshots false true releases-repo https://oss.sonatype.org/service/local/staging/deploy/maven2 true false sonar . https://sonarcloud.io false " > $GITHUB_WORKSPACE/settings.xml + # - name: Setup branch and env + # run: | + # # Strip git ref prefix from version + # echo "BRANCH_NAME=$(echo ${{ github.ref }} | sed -e 's,.*/\(.*\),\1,')" >> $GITHUB_ENV + # echo "GPG_TTY=$(tty)" >> $GITHUB_ENV + # - uses: actions/cache@v1 + # with: + # path: ~/.m2/repository + # key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} + # restore-keys: | + # ${{ runner.os }}-maven-${{ env.BRANCH_NAME }} + # - name: Setup the settings file for ossrh server + # run: echo " ossrh ${{secrets.ossrh_user}} ${{secrets.ossrh_secret}} ossrh true gpg2 ${{secrets.gpg_secret}} allow-snapshots true snapshots-repo https://oss.sonatype.org/content/repositories/snapshots false true releases-repo https://oss.sonatype.org/service/local/staging/deploy/maven2 true false sonar . https://sonarcloud.io false " > $GITHUB_WORKSPACE/settings.xml - - name: Build with Maven - run: | - cd ${{ env.SERVICE_LOCATION}} - mvn clean package -s $GITHUB_WORKSPACE/settings.xml - - name: Get current date - id: date - run: echo "::set-output name=date::$(date +'%Y-%m-%d')" + # - name: Build with Maven + # run: | + # cd ${{ env.SERVICE_LOCATION}} + # mvn clean package -s $GITHUB_WORKSPACE/settings.xml + # - name: Get current date + # id: date + # run: echo "::set-output name=date::$(date +'%Y-%m-%d')" - - name: Build image - run: | - cd "./${{env.SERVICE_LOCATION}}" - docker build . --build-arg SOURCE=mosip --build-arg COMMIT_HASH=$(git rev-parse HEAD) --build-arg COMMIT_ID=$(git rev-parse --short HEAD) --build-arg BUILD_TIME=${{steps.date.outputs.date}} --file Dockerfile --tag ${{ env.SERVICE_NAME }} - - name: Log into registry - run: echo "${{ secrets.release_docker_hub }}" | docker login -u ${{ secrets.actor_docker_hub }} --password-stdin + # - name: Build image + # run: | + # cd "./${{env.SERVICE_LOCATION}}" + # docker build . --build-arg SOURCE=mosip --build-arg COMMIT_HASH=$(git rev-parse HEAD) --build-arg COMMIT_ID=$(git rev-parse --short HEAD) --build-arg BUILD_TIME=${{steps.date.outputs.date}} --file Dockerfile --tag ${{ env.SERVICE_NAME }} + # - name: Log into registry + # run: echo "${{ secrets.release_docker_hub }}" | docker login -u ${{ secrets.actor_docker_hub }} --password-stdin - - name: Push image - run: | - IMAGE_ID=$NAMESPACE/$SERVICE_NAME - # Change all uppercase to lowercase - IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]') - echo "push version ${{steps.getPomVersion.outputs.info}}" - if [[ $BRANCH_NAME == master ]]; then - VERSION=latest - else - VERSION=$BRANCH_NAME - fi - echo IMAGE_ID=$IMAGE_ID - echo VERSION=$VERSION - docker tag $SERVICE_NAME $IMAGE_ID:$VERSION - docker push $IMAGE_ID:$VERSION - - uses: 8398a7/action-slack@v3 - with: - status: ${{ job.status }} - fields: repo,message,commit,workflow,job # selectable (default: repo,message) - env: - SLACK_WEBHOOK_URL: ${{ secrets.SLACK_DEVOPS_WEBHOOK }} # required - if: failure() # Pick up events even if the job fails or is canceled. + # - name: Push image + # run: | + # IMAGE_ID=$NAMESPACE/$SERVICE_NAME + # # Change all uppercase to lowercase + # IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]') + # echo "push version ${{steps.getPomVersion.outputs.info}}" + # if [[ $BRANCH_NAME == master ]]; then + # VERSION=latest + # else + # VERSION=$BRANCH_NAME + # fi + # echo IMAGE_ID=$IMAGE_ID + # echo VERSION=$VERSION + # docker tag $SERVICE_NAME $IMAGE_ID:$VERSION + # docker push $IMAGE_ID:$VERSION + # - uses: 8398a7/action-slack@v3 + # with: + # status: ${{ job.status }} + # fields: repo,message,commit,workflow,job # selectable (default: repo,message) + # env: + # SLACK_WEBHOOK_URL: ${{ secrets.SLACK_DEVOPS_WEBHOOK }} # required + # if: failure() # Pick up events even if the job fails or is canceled. build-automationtests: runs-on: ubuntu-latest From c12eeac5d90773b60893f52c3e9ace2e6e299a51 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 19:10:35 +0530 Subject: [PATCH 082/204] MOSIP-29088 --- .../apirig/admin/fw/util/AdminTestUtil.java | 10 ++--- .../apirig/testrunner/ExtractResource.java | 37 +++++++++++++++++-- .../apirig/testrunner/MosipTestRunner.java | 26 +++++++------ 3 files changed, 52 insertions(+), 21 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index baadfb22c51..ac432d290cf 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -2421,7 +2421,7 @@ public static String getGlobalResourcePath() { } public static String getResourcePath() { - return getGlobalResourcePath() + "/" + RESOURCE_FOLDER_NAME + "/"; + return MosipTestRunner.getGlobalResourcePath() + "/"; } public static void initiateAdminTest() { @@ -2450,12 +2450,12 @@ public static void copymoduleSpecificAndConfigFile(String moduleName) { } else { try { File destination = new File( - RunConfigUtil.getGlobalResourcePath() + "/" + RunConfigUtil.resourceFolderName); - File source = new File(RunConfigUtil.getGlobalResourcePath() + "/" + moduleName); + RunConfigUtil.getGlobalResourcePath()); + File source = new File(RunConfigUtil.getGlobalResourcePath().replace("MosipTestResource/MosipTemporaryTestResource", "") + moduleName); FileUtils.copyDirectoryToDirectory(source, destination); - source = new File(RunConfigUtil.getGlobalResourcePath() + "/config"); - FileUtils.copyDirectoryToDirectory(source, destination); +// source = new File(RunConfigUtil.getGlobalResourcePath() + "/config"); +// FileUtils.copyDirectoryToDirectory(source, destination); logger.info("Copied the test resource successfully for " + moduleName); } catch (Exception e) { logger.error( diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java index b95c3e6c2b7..0201e088561 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/ExtractResource.java @@ -10,23 +10,52 @@ import org.apache.commons.io.FileUtils; import org.apache.log4j.Logger; +import io.mosip.testrig.apirig.authentication.fw.util.RunConfigUtil; + public class ExtractResource { private static final Logger LOGGER = Logger.getLogger(ExtractResource.class); public static void extractCommonResourceFromJar() { getListOfFilesFromJarAndCopyToExternalResource("config/"); - getListOfFilesFromJarAndCopyToExternalResource("syncdata/"); - getListOfFilesFromJarAndCopyToExternalResource("kernel/"); getListOfFilesFromJarAndCopyToExternalResource("customize-emailable-report-template.html"); - getListOfFilesFromJarAndCopyToExternalResource("testngapi.xml"); getListOfFilesFromJarAndCopyToExternalResource("metadata.xml"); getListOfFilesFromJarAndCopyToExternalResource("log4j.properties"); - getListOfFilesFromJarAndCopyToExternalResource("healthCheck/"); getListOfFilesFromJarAndCopyToExternalResource("spring.properties"); getListOfFilesFromJarAndCopyToExternalResource("validations.properties"); getListOfFilesFromJarAndCopyToExternalResource("dbFiles/"); } + public static void copyCommonResources(){ + copyCommonResources("config/"); + copyCommonResources("customize-emailable-report-template.html"); + copyCommonResources("metadata.xml"); + copyCommonResources("log4j.properties"); + copyCommonResources("spring.properties"); + copyCommonResources("validations.properties"); + copyCommonResources("dbFiles/"); + } + + public static void copyCommonResources(String moduleName){ + try { + File destination = new File( + MosipTestRunner.getGlobalResourcePath()); + File source = new File(MosipTestRunner.getGlobalResourcePath().replace("MosipTestResource/MosipTemporaryTestResource", "") + moduleName); + if (source.isDirectory()) + FileUtils.copyDirectoryToDirectory(source, destination); + else { + destination = new File( + MosipTestRunner.getGlobalResourcePath()+ "/" + moduleName); + FileUtils.copyFile(source, destination); + } + + + LOGGER.info("Copied the test resource successfully for " + moduleName); + } catch (Exception e) { + LOGGER.error( + "Exception occured while copying the file for : " + moduleName + " Error : " + e.getMessage()); + } + } + public static void getListOfFilesFromJarAndCopyToExternalResource(String key) { ZipInputStream zipInputStream = null; try { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 983a79821fd..3906dc7fdbf 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -64,10 +64,11 @@ public static void main(String[] arg) { for (String envName : envMap.keySet()) { LOGGER.info(String.format("ENV %s = %s%n", envName, envMap.get(envName))); } - + ExtractResource.removeOldMosipTestTestResource(); if (checkRunType().equalsIgnoreCase("JAR")) { - ExtractResource.removeOldMosipTestTestResource(); ExtractResource.extractCommonResourceFromJar(); + } else { + ExtractResource.copyCommonResources(); } ConfigManager.init(); BaseTestCase.suiteSetup(); @@ -197,7 +198,7 @@ public static String getGlobalResourcePath() { if (checkRunType().equalsIgnoreCase("JAR")) { return new File(jarUrl).getParentFile().getAbsolutePath() + "/MosipTestResource"; } else if (checkRunType().equalsIgnoreCase("IDE")) { - String path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath(); + String path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; if (path.contains(GlobalConstants.TESTCLASSES)) path = path.replace(GlobalConstants.TESTCLASSES, "classes"); return path; @@ -206,15 +207,16 @@ public static String getGlobalResourcePath() { } public static String getResourcePath() { - if (checkRunType().equalsIgnoreCase("JAR")) { - return new File(jarUrl).getParentFile().getAbsolutePath(); - } else if (checkRunType().equalsIgnoreCase("IDE")) { - String path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath(); - if (path.contains(GlobalConstants.TESTCLASSES)) - path = path.replace(GlobalConstants.TESTCLASSES, "classes"); - return path; - } - return "Global Resource File Path Not Found"; + return getGlobalResourcePath(); +// if (checkRunType().equalsIgnoreCase("JAR")) { +// return new File(jarUrl).getParentFile().getAbsolutePath(); +// } else if (checkRunType().equalsIgnoreCase("IDE")) { +// String path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath(); +// if (path.contains(GlobalConstants.TESTCLASSES)) +// path = path.replace(GlobalConstants.TESTCLASSES, "classes"); +// return path; +// } +// return "Global Resource File Path Not Found"; } public static String generatePulicKey() { From c037757b1d2065046efd2c82ae1d242cf9ebc890 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 28 Aug 2023 19:25:18 +0530 Subject: [PATCH 083/204] MOSIP-29088 --- .../io/mosip/testrig/apirig/testrunner/MosipTestRunner.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 3906dc7fdbf..055e296e49e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -196,7 +196,7 @@ public static void startTestRunner() { */ public static String getGlobalResourcePath() { if (checkRunType().equalsIgnoreCase("JAR")) { - return new File(jarUrl).getParentFile().getAbsolutePath() + "/MosipTestResource"; + return new File(jarUrl).getParentFile().getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; } else if (checkRunType().equalsIgnoreCase("IDE")) { String path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; if (path.contains(GlobalConstants.TESTCLASSES)) From e03e066f64cd08ec7f5fac9404a816be5f036644 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 28 Aug 2023 23:49:26 +0530 Subject: [PATCH 084/204] IDA Changes --- .../main/resources/ida/BioAuth/BioAuth.yml | 71 ++----- .../src/main/resources/ida/DemoAuth/error.hbs | 9 - .../src/main/resources/ida/EkycBio/error.hbs | 13 -- .../mobileId/AddIdentity/AddIdentity.yml | 3 +- .../AddIdentity/addIdentityResult.hbs | 8 +- .../mobileId/AddIdentity1/AddIdentity.yml | 182 ------------------ .../AddIdentity1/addIdentityResult.hbs | 11 -- .../AddIdentity1/addIdentity_DEFAULT.hbs | 130 ------------- .../AddIdentity1/addIdentity_DOUBLE.hbs | 102 ---------- .../AddIdentity1/addIdentity_DOUBLE_V3.hbs | 130 ------------- .../AddIdentity1/addIdentity_SINGLE.hbs | 103 ---------- .../AddIdentity1/addIdentity_TRIPLE.hbs | 102 ---------- .../aidGetIndividualIdResult.hbs | 5 - .../SendOTPUIN/individualIdOtpResult.hbs | 9 +- .../src/main/resources/mobileId/error.hbs | 10 +- 15 files changed, 25 insertions(+), 863 deletions(-) delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/AddIdentity.yml delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/addIdentityResult.hbs delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DEFAULT.hbs delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE.hbs delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE_V3.hbs delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_SINGLE.hbs delete mode 100644 automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_TRIPLE.hbs diff --git a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml index 7c79d395d26..f8a043c2c76 100644 --- a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml +++ b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml @@ -419,8 +419,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-018", - "errorMessage": "VID not available in database" + "errorCode": "IDA-MLC-018" } ], "authStatus": false @@ -822,8 +821,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioSubType" + "errorCode": "IDA-MLC-006" } ], "authStatus": false @@ -856,8 +854,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-006", - "errorMessage": "Missing Input Parameter - request/biometrics/0/data/bioType" + "errorCode": "IDA-MLC-006" } ], "authStatus": false @@ -890,9 +887,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-@363GDG", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -925,12 +920,10 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" + "errorCode": "IDA-MLC-007" }, { - "errorCode": "IDA-DPM-004", - "errorMessage": "Device Type and Biometric Type do not match" + "errorCode": "IDA-DPM-004" } ], "authStatus": false @@ -963,9 +956,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - FACE did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } ], "authStatus": false @@ -998,9 +989,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - FACE did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } ], "authStatus": false @@ -1033,9 +1022,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - Iris did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } ], "authStatus": false @@ -1068,9 +1055,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-BIA-001", - "errorMessage": "Biometric data - Finger did not match", - "actionMessage": "Please give your biometrics again" + "errorCode": "IDA-BIA-001" } ], "authStatus": false @@ -1103,9 +1088,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-FIR", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -1138,9 +1121,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-IR", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -1173,9 +1154,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-FIR", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -1208,9 +1187,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-IR", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -1243,9 +1220,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-FC", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -1278,9 +1253,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-011", - "errorMessage": "Unsupported Authentication Type - bio-FC", - "actionMessage": "Please use other Authentication Types in the request" + "errorCode": "IDA-MLC-011" } ], "authStatus": false @@ -1341,8 +1314,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-019", - "errorMessage": "bio-Iris Auth Type is Locked for the UIN" + "errorCode": "IDA-MLC-019" } ], "authStatus": false @@ -1403,12 +1375,10 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-007", - "errorMessage": "Request could not be processed. Please try again" + "errorCode": "IDA-MLC-007" }, { - "errorCode": "IDA-MPA-009", - "errorMessage": "Partner is not registered" + "errorCode": "IDA-MPA-009" } ], "authStatus": false @@ -1470,8 +1440,7 @@ BioAuth: output: '{ "errors": [ { - "errorCode": "IDA-MLC-019", - "errorMessage": "bio-Iris Auth Type is Locked for the UIN" + "errorCode": "IDA-MLC-019" } ], "authStatus": false diff --git a/automationtests/src/main/resources/ida/DemoAuth/error.hbs b/automationtests/src/main/resources/ida/DemoAuth/error.hbs index d81bef285c1..2b007458821 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/error.hbs +++ b/automationtests/src/main/resources/ida/DemoAuth/error.hbs @@ -1,15 +1,6 @@ { "authResponse": { "body": { - "errors": [ - {{#each errors}} - { - "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] "response": { "authStatus": {{authStatus}} } diff --git a/automationtests/src/main/resources/ida/EkycBio/error.hbs b/automationtests/src/main/resources/ida/EkycBio/error.hbs index 4172234dff1..9d51fe4b7fb 100644 --- a/automationtests/src/main/resources/ida/EkycBio/error.hbs +++ b/automationtests/src/main/resources/ida/EkycBio/error.hbs @@ -1,19 +1,6 @@ { - "URL": "$IGNORE$", - "authRequest": "$IGNORE$", "authResponse": { "body": { - "errors": [ - {{#each errors}} - { - "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}", - "actionMessage": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "responseTime": "$IGNORE$", "response": { "kycStatus": {{kycStatus}} } diff --git a/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml index b459e505224..eb5de56b885 100644 --- a/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/mobileId/AddIdentity/AddIdentity.yml @@ -79,8 +79,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/mobileId/AddIdentity/addIdentityResult.hbs index 720254c65ba..ca45b742b9e 100644 --- a/automationtests/src/main/resources/mobileId/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/mobileId/AddIdentity/addIdentityResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.id.create", - "version": "v1", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": [ - - ] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/AddIdentity.yml b/automationtests/src/main/resources/mobileId/AddIdentity1/AddIdentity.yml deleted file mode 100644 index acdebd03104..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/AddIdentity.yml +++ /dev/null @@ -1,182 +0,0 @@ -AddIdentity: - MobileId_AddIdentity_withValidParameters_smoke_Pos: - endPoint: /idrepository/v1/identity/ - role: idrepo - restMethod: post - inputTemplate: mobileId/AddIdentity/addIdentity_$LANGNUMBER$ - outputTemplate: mobileId/AddIdentity/addIdentityResult - input: '{ - "value": "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", - "id": "mosip.id.create", - "registrationId": "$RID$", - "biometricReferenceId": "23452353", - "residenceStatus": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "IDSchemaVersion": "$SCHEMAVERSION$", - "UIN": "$UIN$", - "fullName": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "dateOfBirth": "1992/04/15", - "gender": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "addressLine1": [ - { - "language": "$1STLANG$", - "value": "Line1" - }, - { - "language": "$2NDLANG$", - "value": "Line1" - }, - { - "language": "$3RDLANG$", - "value": "Line1" - } - ], - "addressLine2": [ - { - "language": "$1STLANG$", - "value": "Line2" - }, - { - "language": "$2NDLANG$", - "value": "Line2" - }, - { - "language": "$3RDLANG$", - "value": "Line2" - } - ], - "addressLine3": [ - { - "language": "$1STLANG$", - "value": "Line3" - }, - { - "language": "$2NDLANG$", - "value": "Line3" - }, - { - "language": "$3RDLANG$", - "value": "Line3" - } - ], - "region": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "province": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "city": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "postalCode": "14022", - "email": "residentautomation@gmail.com", - "phone": "9876543210", - "referenceIdentityNumber": "6789545678878", - "version": "v1", - "zone": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "introducerRID": "212124324784879", - "introducerUIN": "212124324784879", - "introducerName": [ - { - "language": "$1STLANG$", - "value": "FR" - }, - { - "language": "$2NDLANG$", - "value": "FR" - }, - { - "language": "$3RDLANG$", - "value": "FR" - } - ], - "category": "individualBiometrics", - "requesttime": "$TIMESTAMP$" -}' - output: '{ - "status":"ACTIVATED" -}' diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentityResult.hbs b/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentityResult.hbs deleted file mode 100644 index 720254c65ba..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentityResult.hbs +++ /dev/null @@ -1,11 +0,0 @@ -{ - "id": "mosip.id.create", - "version": "v1", - "responsetime": "$IGNORE$", - "response": { - "status": "{{status}}" - }, - "errors": [ - - ] -} \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DEFAULT.hbs b/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DEFAULT.hbs deleted file mode 100644 index 93ae8a855bc..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DEFAULT.hbs +++ /dev/null @@ -1,130 +0,0 @@ -{ - "id": "{{id}}", - "request": { - "registrationId": "{{registrationId}}", - "biometricReferenceId": "{{biometricReferenceId}}", - "identity": { - "residenceStatus": [ - {{#each residenceStatus}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "IDSchemaVersion": {{IDSchemaVersion}}, - "UIN": "{{UIN}}", - "fullName": [ - {{#each fullName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "dateOfBirth": "{{dateOfBirth}}", - "gender": [ - {{#each gender}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "addressLine1": [ - {{#each addressLine1}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "addressLine2": [ - {{#each addressLine2}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "addressLine3": [ - {{#each addressLine3}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "region": [ - {{#each region}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "province": [ - {{#each province}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "city": [ - {{#each city}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "postalCode": "{{postalCode}}", - "email": "{{email}}", - "phone": "{{phone}}", - "referenceIdentityNumber": "{{referenceIdentityNumber}}", - "zone": [ - {{#each zone}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "introducerRID": "{{introducerRID}}", - "introducerUIN": "{{introducerUIN}}", - "introducerName": [ - {{#each introducerName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "individualBiometrics": { - "format": "cbeff", - "version": 1, - "value": "fileReferenceID" - } - }, - "documents": [ - { - "value": "{{value}}", - "category": "{{category}}" - } - ] - }, - "requesttime": "{{requesttime}}", - "version": "{{version}}" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE.hbs b/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE.hbs deleted file mode 100644 index 132cc43fdea..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE.hbs +++ /dev/null @@ -1,102 +0,0 @@ -{ - "id": "{{id}}", - "request": { - "registrationId": "{{registrationId}}", - "biometricReferenceId": "{{biometricReferenceId}}", - "identity": { - "residenceStatus": [ - {{#each residenceStatus}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "IDSchemaVersion": {{IDSchemaVersion}}, - "UIN": "{{UIN}}", - "fullName": [ - {{#each fullName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "dateOfBirth": "{{dateOfBirth}}", - "gender": [ - {{#each gender}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "region": [ - {{#each region}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "province": [ - {{#each province}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "city": [ - {{#each city}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "postalCode": "{{postalCode}}", - "email": "{{email}}", - "phone": "{{phone}}", - "zone": [ - {{#each zone}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "introducerRID": "{{introducerRID}}", - "introducerUIN": "{{introducerUIN}}", - "introducerName": [ - {{#each introducerName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "individualBiometrics": { - "format": "cbeff", - "version": 1, - "value": "fileReferenceID" - } - }, - "documents": [ - { - "value": "{{value}}", - "category": "{{category}}" - } - ] - }, - "requesttime": "{{requesttime}}", - "version": "{{version}}" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE_V3.hbs b/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE_V3.hbs deleted file mode 100644 index 2f1538a1a8e..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_DOUBLE_V3.hbs +++ /dev/null @@ -1,130 +0,0 @@ -{ - "id": "{{id}}", - "request": { - "registrationId": "{{registrationId}}", - "biometricReferenceId": "{{biometricReferenceId}}", - "identity": { - "residenceStatus": [ - {{#each residenceStatus}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "IDSchemaVersion": $SCHEMAVERSION$, - "UIN": "{{UIN}}", - "fullName": [ - {{#each fullName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "dateOfBirth": "{{dateOfBirth}}", - "gender": [ - {{#each gender}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "addressLine1": [ - {{#each addressLine1}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "addressLine2": [ - {{#each addressLine2}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "addressLine3": [ - {{#each addressLine3}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "region": [ - {{#each region}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "province": [ - {{#each province}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "city": [ - {{#each city}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "postalCode": "{{postalCode}}", - "email": "{{email}}", - "phone": "{{phone}}", - "referenceIdentityNumber": "{{referenceIdentityNumber}}", - "zone": [ - {{#each zone}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "introducerRID": "{{introducerRID}}", - "introducerUIN": "{{introducerUIN}}", - "introducerName": [ - {{#each introducerName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "individualBiometrics": { - "format": "cbeff", - "version": 1, - "value": "fileReferenceID" - } - }, - "documents": [ - { - "value": "{{value}}", - "category": "{{category}}" - } - ] - }, - "requesttime": "{{requesttime}}", - "version": "{{version}}" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_SINGLE.hbs b/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_SINGLE.hbs deleted file mode 100644 index bdaa96775c4..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_SINGLE.hbs +++ /dev/null @@ -1,103 +0,0 @@ -{ - "id": "{{id}}", - "request": { - "registrationId": "{{registrationId}}", - "biometricReferenceId": "{{biometricReferenceId}}", - "identity": { - "residenceStatus": [ - {{#each residenceStatus}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "IDSchemaVersion": {{IDSchemaVersion}}, - "UIN": "{{UIN}}", - "fullName": [ - {{#each fullName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "dateOfBirth": "{{dateOfBirth}}", - "gender": [ - {{#each gender}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "region": [ - {{#each region}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "province": [ - {{#each province}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "city": [ - {{#each city}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "postalCode": "{{postalCode}}", - "email": "{{email}}", - "phone": "{{phone}}", - "referenceIdentityNumber": "{{referenceIdentityNumber}}", - "zone": [ - {{#each zone}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "introducerRID": "{{introducerRID}}", - "introducerUIN": "{{introducerUIN}}", - "introducerName": [ - {{#each introducerName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "individualBiometrics": { - "format": "cbeff", - "version": 1, - "value": "fileReferenceID" - } - }, - "documents": [ - { - "value": "{{value}}", - "category": "{{category}}" - } - ] - }, - "requesttime": "{{requesttime}}", - "version": "{{version}}" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_TRIPLE.hbs b/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_TRIPLE.hbs deleted file mode 100644 index 132cc43fdea..00000000000 --- a/automationtests/src/main/resources/mobileId/AddIdentity1/addIdentity_TRIPLE.hbs +++ /dev/null @@ -1,102 +0,0 @@ -{ - "id": "{{id}}", - "request": { - "registrationId": "{{registrationId}}", - "biometricReferenceId": "{{biometricReferenceId}}", - "identity": { - "residenceStatus": [ - {{#each residenceStatus}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "IDSchemaVersion": {{IDSchemaVersion}}, - "UIN": "{{UIN}}", - "fullName": [ - {{#each fullName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "dateOfBirth": "{{dateOfBirth}}", - "gender": [ - {{#each gender}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "region": [ - {{#each region}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "province": [ - {{#each province}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "city": [ - {{#each city}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "postalCode": "{{postalCode}}", - "email": "{{email}}", - "phone": "{{phone}}", - "zone": [ - {{#each zone}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "introducerRID": "{{introducerRID}}", - "introducerUIN": "{{introducerUIN}}", - "introducerName": [ - {{#each introducerName}} - { - "language": "{{language}}", - "value": "{{value}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "individualBiometrics": { - "format": "cbeff", - "version": 1, - "value": "fileReferenceID" - } - }, - "documents": [ - { - "value": "{{value}}", - "category": "{{category}}" - } - ] - }, - "requesttime": "{{requesttime}}", - "version": "{{version}}" -} \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AidGetIndividualId/aidGetIndividualIdResult.hbs b/automationtests/src/main/resources/mobileId/AidGetIndividualId/aidGetIndividualIdResult.hbs index 4e14a1bfc7a..eec0b1866fc 100644 --- a/automationtests/src/main/resources/mobileId/AidGetIndividualId/aidGetIndividualIdResult.hbs +++ b/automationtests/src/main/resources/mobileId/AidGetIndividualId/aidGetIndividualIdResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "individualId": "$IGNORE$", - "transactionID": "$IGNORE$", "aidStatus": "{{aidStatus}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs b/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs index bd241fc2088..257f951c523 100644 --- a/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs +++ b/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs @@ -1,12 +1,7 @@ { "id": "mosip.identity.otp.internal", "version": "1.0", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "maskedMobile": "{{maskedMobile}}", - "maskedEmail": "$IGNORE$" - }, - "errors": "$IGNORE$" + "maskedMobile": "{{maskedMobile}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/error.hbs b/automationtests/src/main/resources/mobileId/error.hbs index 76ee450326e..f4bcb6bee67 100644 --- a/automationtests/src/main/resources/mobileId/error.hbs +++ b/automationtests/src/main/resources/mobileId/error.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "timestamp": "$IGNORE$", - "status": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "message": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} From 11cee58f44a680ed3dd2485504d6fe013a30dd75 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 29 Aug 2023 00:24:10 +0530 Subject: [PATCH 085/204] MOBILEID Changes --- .../mobileId/AuthLock/createAuthLock.yml | 38 +- .../mobileId/AuthUnLock/createAuthUnLock.yml | 24 +- .../mobileId/BindingOtp/BindingOtp.yml | 318 ++++---- .../mobileId/BindingOtp/BindingOtpResult.hbs | 9 +- .../CredentialCheckStatus.yml | 14 +- .../credentialcheckstatusResult.hbs | 9 +- .../DownloadCredential/DownloadCredential.yml | 6 - .../DownloadWithReqid/DownloadWithReqid.yml | 3 +- .../downloadwithreqidResult.hbs | 12 +- .../RequestCredentials/ReqCredential.yml | 27 +- .../ReqCredentialResult.hbs | 10 +- .../GenerateVID/createGenerateVID.yml | 30 +- .../mobileId/SendOTP/createSendOTPResult.hbs | 10 +- .../mobileId/ValidateOTP/ValidateOTP.yml | 36 +- .../ValidateOTP/ValidateOTPResult.hbs | 4 +- .../mobileId/WalletBinding/WalletBinding.yml | 695 ++++++++---------- 16 files changed, 507 insertions(+), 738 deletions(-) diff --git a/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml index e2f20d99510..f6e0c43b3b5 100644 --- a/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml @@ -21,12 +21,9 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthLock_InValid_Otp_All: @@ -53,14 +50,11 @@ AuthLock: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthLock_with_invalidUIN_Valid_Otp_sid: @@ -87,14 +81,11 @@ AuthLock: output: '{ "errors": [ { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" + "errorCode": "RES-SER-410" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthLock_Valid_VID_All: @@ -119,12 +110,9 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthLock_with_invalidVID_Valid_Otp: @@ -151,14 +139,11 @@ AuthLock: output: '{ "errors": [ { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" + "errorCode": "RES-SER-410" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthLock_invalidVID_Valid_Otp: @@ -185,13 +170,10 @@ AuthLock: output: '{ "errors": [ { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" + "errorCode": "RES-SER-410" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' diff --git a/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml index b7089cfb918..febab4b55ef 100644 --- a/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml @@ -22,12 +22,9 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthUnLock_Valid_UIN_With_VID_All: @@ -53,12 +50,9 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthUnLock_With_InValid_OTP_All: @@ -86,14 +80,11 @@ AuthUnlock: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_AuthUnLock_InValid_OTP_With_VID_All: @@ -121,13 +112,10 @@ AuthUnlock: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml index 260b4f54748..7bd03976cfe 100644 --- a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml +++ b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml @@ -8,9 +8,9 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/BindingOtp/BindingOtpResult input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "maskedMobile": "$IGNORE$" @@ -25,9 +25,9 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/BindingOtp/BindingOtpResult input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "maskedMobile": "$IGNORE$" @@ -41,15 +41,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "@#DSDFD@#", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "@#DSDFD@#", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "message": "$IGNORE$" + "errorCode": "IDA-MLC-009" } ] }' @@ -62,15 +61,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$REMOVE$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$REMOVE$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -83,15 +81,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_identifier", - "message": "$IGNORE$" + "errorCode": "invalid_identifier" } ] }' @@ -104,15 +101,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "null", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "null", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "message": "$IGNORE$" + "errorCode": "IDA-MLC-009" } ] }' @@ -125,15 +121,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "E M A I L"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "E M A I L"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -146,15 +141,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "sdsgsg"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "sdsgsg"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -167,15 +161,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "$IGNORE$"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "$IGNORE$"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -188,15 +181,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: ""}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: ""}] }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -209,15 +201,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "null"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "null"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -230,15 +221,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": "$IGNORE$" + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": "$IGNORE$" }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -251,15 +241,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": "" + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": "" }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -272,15 +261,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": "null" + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": "null" }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -293,15 +281,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "2022-11-08T06:35:53", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "2022-11-08T06:35:53", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -314,15 +301,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "2022-11-07T06:51:30.195Z", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "2022-11-07T06:51:30.195Z", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -335,15 +321,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "2033-11-07T06:51:30.195Z", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "2033-11-07T06:51:30.195Z", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -356,15 +341,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$IGNORE$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$IGNORE$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -377,15 +361,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -398,15 +381,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "@#DSDFD@#", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "@#DSDFD@#", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "message": "$IGNORE$" + "errorCode": "IDA-MLC-009" } ] }' @@ -419,15 +401,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$REMOVE$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$REMOVE$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -440,15 +421,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_identifier", - "message": "$IGNORE$" + "errorCode": "invalid_identifier" } ] }' @@ -461,15 +441,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "null", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$TIMESTAMP$", + "individualId": "null", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "IDA-MLC-009", - "message": "$IGNORE$" + "errorCode": "IDA-MLC-009" } ] }' @@ -482,15 +461,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "E M A I L"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "E M A I L"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -503,15 +481,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "sdsgsg"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "sdsgsg"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -524,15 +501,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "$IGNORE$"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "$IGNORE$"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -545,15 +521,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: ""}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: ""}] }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -566,15 +541,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "null"}] + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "null"}] }' output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-011", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-011" } ] }' @@ -587,15 +561,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": "$IGNORE$" + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": "$IGNORE$" }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -608,15 +581,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": "" + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": "" }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -629,15 +601,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": "null" + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": "null" }' output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", - "message": "$IGNORE$" + "errorCode": "invalid_otp_channel" } ] }' @@ -650,15 +621,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "2022-11-08T06:35:53", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "2022-11-08T06:35:53", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -671,15 +641,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "2022-11-07T06:51:30.195Z", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "2022-11-07T06:51:30.195Z", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -692,15 +661,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "2033-11-07T06:51:30.195Z", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "2033-11-07T06:51:30.195Z", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -713,15 +681,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "$IGNORE$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "$IGNORE$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' @@ -734,15 +701,14 @@ BindingOtp: inputTemplate: mobileId/BindingOtp/BindingOtp outputTemplate: mobileId/error input: '{ - "requestTime": "", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "EMAIL"}] + "requestTime": "", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "EMAIL"}] }' output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtpResult.hbs b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtpResult.hbs index 55654efeb19..e3cf3799217 100644 --- a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtpResult.hbs +++ b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtpResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "str": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "maskedEmail": "$IGNORE$", "maskedMobile": "{{maskedMobile}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml index 968f855056f..0fb41596ac0 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml @@ -9,8 +9,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials__All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "ISSUED" }' MobileId_CredentialsStatus_euin_With_VID_All_Valid_Smoke: @@ -23,8 +21,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_All_Valid_Smoke_with_VID_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "ISSUED" }' @@ -38,13 +34,5 @@ CredentialsStatus: "requestId": "$er45" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", - "statusCode": "ISSUED", - "errors": [ - { - "errorCode": "RES-SER-29", - "errorMessage": "$IGNORE$" - } - ] + "statusCode": "ISSUED" }' diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs b/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs index c454c7cd21a..5bd4b5fb05f 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "id": "{{id}}", - "requestId": "{{requestId}}", "statusCode": "{{statusCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadCredential/DownloadCredential.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadCredential/DownloadCredential.yml index 69e355d9e86..dbcfe34138a 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadCredential/DownloadCredential.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadCredential/DownloadCredential.yml @@ -10,8 +10,6 @@ DownloadCredential: "individualId": "9653041697" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' @@ -26,8 +24,6 @@ DownloadCredential: "individualId": "9653041697" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' @@ -42,7 +38,5 @@ DownloadCredential: "individualId": "$ghg6" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml index fb8202eec47..4a2f39673c8 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml @@ -11,8 +11,7 @@ DownloadCredential: "individualId": "$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$" }' output: ' { - "Content-Type": "application/pdf", - "filename": "$IGNORE$" + "Content-Type": "application/pdf" }' MobileId_CredentialsStatus_StatusCode_InValid_Smoke_euin: endPoint: /residentmobileapp/credentialshare/download diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/downloadwithreqidResult.hbs b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/downloadwithreqidResult.hbs index 1e2f7348e5f..6f35f5edda5 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/downloadwithreqidResult.hbs +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/downloadwithreqidResult.hbs @@ -1,14 +1,4 @@ { "credential": { - "biometrics": { - "face": "$IGNORE$" - }, - "province": $IGNORE$, - "phone": "$IGNORE$", - "city": $IGNORE$, - "postalCode": "$IGNORE$", - "fullName": $IGNORE$, - "region": $IGNORE$ - }, - "verifiableCredential": $IGNORE$ + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml index 658c067cce0..10e5da1b4d0 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -23,8 +23,7 @@ RequestCredentials: "id": "$IGNORE$", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_RequestCredentials_All_Valid_Smoke_with_VID_sid: @@ -51,8 +50,7 @@ RequestCredentials: "id": "$IGNORE$", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_RequestCredentials_InValid_Otp_UIN_sid: @@ -78,14 +76,12 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_RequestCredentials_InValid_TransactionId_sid: @@ -111,14 +107,12 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -145,14 +139,12 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" + "errorCode": "RES-SER-410" } ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -180,7 +172,6 @@ RequestCredentials: "id": "$IGNORE$", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs index 436bbc57722..b8eed36f548 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$TIMESTAMP$", - "metadata": "$IGNORE$", "response": { - "id": "{{id}}", - "requestId": "$IGNORE$" - }, - "errors": "$IGNORE$" + "id": "{{id}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml index 079389af775..9f586645196 100644 --- a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml @@ -21,12 +21,10 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_Generate_Perpetual_VID_InValid_Otp_sid: @@ -53,14 +51,12 @@ GenerateVID: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_Generate_Perpetual_VID_with_InvalidUIN_Valid_Otp_sid: @@ -87,14 +83,12 @@ GenerateVID: output: '{ "errors": [ { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" + "errorCode": "RES-SER-410" } ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -120,12 +114,10 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -153,14 +145,12 @@ GenerateVID: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "errorMessage": "Invalid Input Parameter - transactionID" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -186,11 +176,9 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs index bd241fc2088..7e8707fc0db 100644 --- a/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs @@ -1,12 +1,6 @@ { "id": "mosip.identity.otp.internal", - "version": "1.0", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "maskedMobile": "{{maskedMobile}}", - "maskedEmail": "$IGNORE$" - }, - "errors": "$IGNORE$" + "maskedMobile": "{{maskedMobile}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTP.yml b/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTP.yml index 65240b4d549..d843b6b61b5 100644 --- a/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTP.yml +++ b/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTP.yml @@ -12,8 +12,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "maskedMobile": "XXXXXX3210", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "maskedMobile": "XXXXXX3210" }' Resident_SendOTP_Valid_UIN_Phone_Smoke: endPoint: /resident/v1/req/otp @@ -29,8 +28,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "maskedMobile": "XXXXXX3210", - "maskedEmail": "$IGNORE$" + "maskedMobile": "XXXXXX3210" }' Resident_SendOTP_Valid_UIN_Email_Smoke: endPoint: /resident/v1/req/otp @@ -46,8 +44,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "maskedMobile": "$IGNORE$", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "maskedMobile": "$IGNORE$" }' Resident_SendOTP_RevokedVID_Invalid: endPoint: /resident/v1/req/otp @@ -62,8 +59,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-MLC-018", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-018" }' Resident_SendOTP_Valid_UIN_Invalid_empty_otpChannel: endPoint: /resident/v1/req/otp @@ -79,8 +75,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-OTA-008", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-OTA-008" }' Resident_SendOTP_InValid_individualId: endPoint: /resident/v1/req/otp @@ -95,8 +90,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-009" }' Resident_SendOTP_InValid_Missing_individualId: endPoint: /resident/v1/req/otp @@ -111,8 +105,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-009" }' Resident_SendOTP_InValid_Empty_transactionID: endPoint: /resident/v1/req/otp @@ -127,8 +120,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-MLC-006", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-006" }' Resident_SendOTP_InValid_transactionID: endPoint: /resident/v1/req/otp @@ -143,8 +135,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-009" }' Resident_SendOTP_InValid_Missing_transactionID: endPoint: /resident/v1/req/otp @@ -159,8 +150,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "RES-SER-425", - "message": "$IGNORE$" + "errorCode": "RES-SER-425" }' Resident_SendOTP_InValid_Empty_requestTime: endPoint: /resident/v1/req/otp @@ -175,8 +165,7 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "IDA-MLC-006", - "errorMessage": "$IGNORE$" + "errorCode": "IDA-MLC-006" }' Resident_SendOTP_InValid_requestTime: endPoint: /resident/v1/req/otp @@ -191,6 +180,5 @@ SendOTP: "individualIdType": "UIN" }' output: '{ - "errorCode": "RES-SER-425", - "message": "$IGNORE$" + "errorCode": "RES-SER-425" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTPResult.hbs b/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTPResult.hbs index 22e196eabfb..689fb082bee 100644 --- a/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTPResult.hbs +++ b/automationtests/src/main/resources/mobileId/ValidateOTP/ValidateOTPResult.hbs @@ -1,9 +1,7 @@ { "id": "mosip.identity.auth.internal", "version": "v1", - "responsetime": "$IGNORE$", "response": { - "authStatus": {{authStatus}}, - "transactionID": "$IGNORE$" + "authStatus": {{authStatus}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml b/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml index 723a8f14ee3..88d67be0991 100644 --- a/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml +++ b/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml @@ -18,7 +18,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -27,8 +27,8 @@ WalletBinding: output: '{ "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -51,7 +51,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -60,8 +60,8 @@ WalletBinding: output: '{ "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -84,7 +84,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -93,14 +93,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -123,7 +122,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -132,14 +131,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -162,7 +160,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -171,14 +169,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -201,7 +198,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -210,14 +207,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -240,7 +236,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -249,14 +245,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -279,7 +274,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -288,14 +283,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -318,7 +312,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -327,14 +321,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_individual_id", - "message": "$IGNORE$" + "errorCode": "invalid_individual_id" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -357,7 +350,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -366,14 +359,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -396,7 +388,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -405,14 +397,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_individual_id", - "message": "$IGNORE$" + "errorCode": "invalid_individual_id" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -435,7 +426,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -444,14 +435,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_individual_id", - "message": "$IGNORE$" + "errorCode": "invalid_individual_id" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -474,7 +464,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -483,14 +473,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -513,7 +502,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -522,14 +511,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -552,7 +540,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -561,14 +549,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -591,7 +578,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -600,14 +587,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -630,7 +616,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -639,14 +625,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -669,7 +654,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -678,14 +663,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -708,7 +692,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -717,14 +701,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge", - "message": "$IGNORE$" + "errorCode": "invalid_challenge" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -747,7 +730,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -756,14 +739,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge", - "message": "$IGNORE$" + "errorCode": "invalid_challenge" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -786,7 +768,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -795,14 +777,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge", - "message": "$IGNORE$" + "errorCode": "invalid_challenge" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -825,7 +806,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -834,14 +815,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -864,7 +844,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -873,14 +853,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -903,7 +882,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -912,14 +891,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -942,7 +920,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -951,14 +929,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -981,7 +958,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -990,14 +967,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1020,7 +996,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1029,14 +1005,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1059,7 +1034,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1068,14 +1043,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1098,7 +1072,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1107,14 +1081,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1137,7 +1110,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1146,14 +1119,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1176,7 +1148,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1185,14 +1157,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1215,7 +1186,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1224,14 +1195,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1254,7 +1224,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1263,14 +1233,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1293,7 +1262,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1302,14 +1271,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1332,7 +1300,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1341,14 +1309,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1371,7 +1338,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1380,14 +1347,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1410,7 +1376,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1419,14 +1385,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1449,7 +1414,7 @@ WalletBinding: "publicKey": "ghj$4", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1458,14 +1423,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-028", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-028" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1488,7 +1452,7 @@ WalletBinding: "publicKey": "null", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1497,14 +1461,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-028", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-028" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1527,7 +1490,7 @@ WalletBinding: "publicKey": "$REMOVE$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1536,14 +1499,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-028", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-028" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1566,7 +1528,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1575,14 +1537,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1605,7 +1566,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1614,14 +1575,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1644,7 +1604,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1653,14 +1613,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1683,7 +1642,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1692,14 +1651,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1722,7 +1680,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1731,14 +1689,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_request", - "message": "$IGNORE$" + "errorCode": "invalid_request" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1761,7 +1718,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1770,14 +1727,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1800,7 +1756,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1809,14 +1765,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_individual_id", - "message": "$IGNORE$" + "errorCode": "invalid_individual_id" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1839,7 +1794,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1848,14 +1803,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1878,7 +1832,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1887,14 +1841,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_individual_id", - "message": "$IGNORE$" + "errorCode": "invalid_individual_id" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1917,7 +1870,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1926,14 +1879,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_individual_id", - "message": "$IGNORE$" + "errorCode": "invalid_individual_id" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1956,7 +1908,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -1965,14 +1917,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -1995,7 +1946,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2004,14 +1955,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2034,7 +1984,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2043,14 +1993,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2073,7 +2022,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2082,14 +2031,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2112,7 +2060,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2121,14 +2069,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2151,7 +2098,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2160,14 +2107,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2190,7 +2136,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2199,14 +2145,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge", - "message": "$IGNORE$" + "errorCode": "invalid_challenge" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2229,7 +2174,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2238,14 +2183,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge", - "message": "$IGNORE$" + "errorCode": "invalid_challenge" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2268,7 +2212,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2277,14 +2221,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge", - "message": "$IGNORE$" + "errorCode": "invalid_challenge" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2307,7 +2250,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2316,14 +2259,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "binding_auth_failed", - "message": "$IGNORE$" + "errorCode": "binding_auth_failed" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2346,7 +2288,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2355,14 +2297,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2385,7 +2326,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2394,14 +2335,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2424,7 +2364,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2433,14 +2373,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2463,7 +2402,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2472,14 +2411,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2502,7 +2440,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2511,14 +2449,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2541,7 +2478,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2550,14 +2487,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2580,7 +2516,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2589,14 +2525,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2619,7 +2554,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2628,14 +2563,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2658,7 +2592,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2667,14 +2601,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2697,7 +2630,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2706,14 +2639,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2736,7 +2668,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2745,14 +2677,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2775,7 +2706,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2784,14 +2715,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2814,7 +2744,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2823,14 +2753,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2853,7 +2782,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2862,14 +2791,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2892,7 +2820,7 @@ WalletBinding: "publicKey": "$PUBLICKEYFORBINDING$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2901,14 +2829,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_auth_factor_type_or_challenge_format", - "message": "$IGNORE$" + "errorCode": "invalid_auth_factor_type_or_challenge_format" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2931,7 +2858,7 @@ WalletBinding: "publicKey": "ghj$4", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2940,14 +2867,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-028", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-028" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -2970,7 +2896,7 @@ WalletBinding: "publicKey": "null", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -2979,14 +2905,13 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-028", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-028" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" + } }' @@ -3009,7 +2934,7 @@ WalletBinding: "publicKey": "$REMOVE$", "sendOtp":{ "requestTime": "$TIMESTAMP$", - "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", + "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" @@ -3018,13 +2943,11 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "RESIDENT-APP-028", - "message": "$IGNORE$" + "errorCode": "RESIDENT-APP-028" } ], "sendOtpResp": { "maskedMobile": "$IGNORE$", - "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult", - "maskedEmail": "$IGNORE$" + "sendOtpResTemplate":"mobileId/BindingOtp/BindingOtpResult" } }' \ No newline at end of file From e50d1b1eaeadaa5792ab11ed97a610bad5be640a Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 29 Aug 2023 06:31:16 +0530 Subject: [PATCH 086/204] MOSIP-29080 --- .../AddLostUinApplication.yml | 3 +- .../addUpdateRegistrationResult.hbs | 1 - .../BookMultipleAppointment.yml | 7 +-- .../cancelApplicationsAppointmentResult.hbs | 3 - .../preReg/CopyDocument/CopyDocument.yml | 9 +-- .../DeleteLostUinApplication.yml | 3 +- .../DeletePreRegistration.yml | 3 +- .../FetchApplicationByPrid.yml | 3 +- .../FetchAppointmentDetailsByPrid.yml | 3 +- .../GetAllApplications/GetAllApplications.yml | 3 +- .../GetAllDocForPrId/GetAllDocForPrId.yml | 3 +- .../GetApplicationStatusWithPrId.yml | 6 +- .../GetApplicationWithPrId.yml | 3 +- .../GetAppointmentDetails.yml | 3 +- .../GetAvailableSlotForRegCentreId.yml | 3 +- .../GetPRIDByDateRange/GetPRIDByDateRange.yml | 45 +++++--------- .../GetPRIDForRegCent/GetPRIDForRegCent.yml | 3 +- .../GetPreRegInfoByPrid.yml | 3 +- .../GetSpecificDocumentforaPRID.yml | 6 +- .../GetUpdatedDateTimeByPrid.yml | 3 +- .../preReg/Transliteration/Translate.yml | 6 +- .../preReg/UpdateDocRefID/UpdateDocRefID.yml | 11 ++-- .../UpdateDocRefID/updateDocRefIDResult.hbs | 1 - .../UpdatePreRegStatus/updatePreRegStatus.yml | 14 ++--- .../updatePreRegStatusResult.hbs | 1 - .../UpdatePreregistration.yml | 30 +++------ .../preReg/ValidateOtp/ValidateOtp.yml | 4 +- .../preReg/ValidateOtp/validateOtpResult.hbs | 3 - .../bookAppointment/bookAppointment.yml | 51 ++++++--------- .../bookAppointment/bookAppointmentResult.hbs | 4 -- .../bookAppointmentByPRID.yml | 62 +++++++------------ .../bookAppointmentByPRIDResult.hbs | 7 --- .../preReg/createPrereg/createPrereg.yml | 30 +++------ 33 files changed, 111 insertions(+), 229 deletions(-) diff --git a/automationtests/src/main/resources/preReg/AddLostUinApplication/AddLostUinApplication.yml b/automationtests/src/main/resources/preReg/AddLostUinApplication/AddLostUinApplication.yml index 8ff226d1a4b..36333ffd09b 100644 --- a/automationtests/src/main/resources/preReg/AddLostUinApplication/AddLostUinApplication.yml +++ b/automationtests/src/main/resources/preReg/AddLostUinApplication/AddLostUinApplication.yml @@ -32,8 +32,7 @@ AddLostUinApplication: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_014", - "message": "Lang code is invalid" + "errorCode": "PRG_CORE_REQ_014" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs b/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs index ee436d9403f..c9bc8b39df3 100644 --- a/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs +++ b/automationtests/src/main/resources/preReg/AddUpdateRegistration/addUpdateRegistrationResult.hbs @@ -1,7 +1,6 @@ { "response": { "applicationStatusCode": "{{applicationStatusCode}}", - "langCode": "$IGNORE$", "bookingType": "{{bookingType}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/BookMultipleAppointment/BookMultipleAppointment.yml b/automationtests/src/main/resources/preReg/BookMultipleAppointment/BookMultipleAppointment.yml index 75cf8ac3ab7..540130b20f6 100644 --- a/automationtests/src/main/resources/preReg/BookMultipleAppointment/BookMultipleAppointment.yml +++ b/automationtests/src/main/resources/preReg/BookMultipleAppointment/BookMultipleAppointment.yml @@ -2,6 +2,7 @@ BookMultipleAppointment: Prereg_BookMultipleAppointment_All_Valid_Smoke: endPoint: /preregistration/v1/appointment role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/BookMultipleAppointment/bookMultipleAppointment outputTemplate: preReg/BookMultipleAppointment/bookMultipleAppointmentResult @@ -28,10 +29,4 @@ BookMultipleAppointment: }] }' output: '{ -"bookingStatusResponse": [{ - "bookingMessage": "Appointment booked successfully" - }] -"bookingStatusResponse": [{ - "bookingMessage": "Appointment booked successfully" - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs b/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/CancelApplicationsAppointment/cancelApplicationsAppointmentResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/CopyDocument/CopyDocument.yml b/automationtests/src/main/resources/preReg/CopyDocument/CopyDocument.yml index 3ab1f8dadec..6a94b624d06 100644 --- a/automationtests/src/main/resources/preReg/CopyDocument/CopyDocument.yml +++ b/automationtests/src/main/resources/preReg/CopyDocument/CopyDocument.yml @@ -26,8 +26,7 @@ CopyDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_017", - "message": "Document Category code is invalid" + "errorCode": "PRG_CORE_REQ_017" } ] }' @@ -44,8 +43,7 @@ CopyDocument: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_017", - "message": "Document Category code is invalid" + "errorCode": "PRG_CORE_REQ_017" } ] }' @@ -62,8 +60,7 @@ CopyDocument: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml b/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml index 5b79f404c9a..246f548844c 100644 --- a/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml +++ b/automationtests/src/main/resources/preReg/DeleteLostUinApplication/DeleteLostUinApplication.yml @@ -24,8 +24,7 @@ DeleteLostUinApplication: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No record found for the requested user id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/DeletePreRegistration/DeletePreRegistration.yml b/automationtests/src/main/resources/preReg/DeletePreRegistration/DeletePreRegistration.yml index cf3f31291fa..af6cb0780be 100644 --- a/automationtests/src/main/resources/preReg/DeletePreRegistration/DeletePreRegistration.yml +++ b/automationtests/src/main/resources/preReg/DeletePreRegistration/DeletePreRegistration.yml @@ -23,8 +23,7 @@ DeletePreRegistration: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No record found for the requested user id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/FetchApplicationByPrid/FetchApplicationByPrid.yml b/automationtests/src/main/resources/preReg/FetchApplicationByPrid/FetchApplicationByPrid.yml index bf5a3fd0d36..b6adbbaa5d8 100644 --- a/automationtests/src/main/resources/preReg/FetchApplicationByPrid/FetchApplicationByPrid.yml +++ b/automationtests/src/main/resources/preReg/FetchApplicationByPrid/FetchApplicationByPrid.yml @@ -23,8 +23,7 @@ FetchApplicationByPrid: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/FetchAppointmentDetailsByPrid.yml b/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/FetchAppointmentDetailsByPrid.yml index 13f7b12a6bc..c5f28547e5b 100644 --- a/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/FetchAppointmentDetailsByPrid.yml +++ b/automationtests/src/main/resources/preReg/FetchAppointmentDetailsByPrid/FetchAppointmentDetailsByPrid.yml @@ -23,8 +23,7 @@ FetchAppointmentDetailsByPrid: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml b/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml index f6a3601d62e..f433644fc86 100644 --- a/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml +++ b/automationtests/src/main/resources/preReg/GetAllApplications/GetAllApplications.yml @@ -23,8 +23,7 @@ GetAllApplications: output: '{ "errors": [ { - "errorCode": "PRG_APP_016", - "message": "Invalid booking type" + "errorCode": "PRG_APP_016" } ] }' diff --git a/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml b/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml index 9ab1a0991a3..02e97b7ea52 100644 --- a/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml +++ b/automationtests/src/main/resources/preReg/GetAllDocForPrId/GetAllDocForPrId.yml @@ -25,8 +25,7 @@ GetAllDocForPrId: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/GetApplicationStatusWithPrId.yml b/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/GetApplicationStatusWithPrId.yml index 85fed462a44..5804173f01e 100644 --- a/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/GetApplicationStatusWithPrId.yml +++ b/automationtests/src/main/resources/preReg/GetApplicationStatusWithPrId/GetApplicationStatusWithPrId.yml @@ -23,8 +23,7 @@ GetApplicationStatusWithPrId: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' @@ -40,8 +39,7 @@ GetApplicationStatusWithPrId: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetApplicationWithPrId/GetApplicationWithPrId.yml b/automationtests/src/main/resources/preReg/GetApplicationWithPrId/GetApplicationWithPrId.yml index f9d1c11316d..a6d6ed9b187 100644 --- a/automationtests/src/main/resources/preReg/GetApplicationWithPrId/GetApplicationWithPrId.yml +++ b/automationtests/src/main/resources/preReg/GetApplicationWithPrId/GetApplicationWithPrId.yml @@ -11,8 +11,7 @@ GetApplicationWithPrId: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml b/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml index 13a46e1d18d..d4ef1efeb83 100644 --- a/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml +++ b/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml @@ -35,8 +35,7 @@ GetAppointmentDetails: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/GetAvailableSlotForRegCentreId.yml b/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/GetAvailableSlotForRegCentreId.yml index 4842094be79..9405621a418 100644 --- a/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/GetAvailableSlotForRegCentreId.yml +++ b/automationtests/src/main/resources/preReg/GetAvailableSlotForRegCentreId/GetAvailableSlotForRegCentreId.yml @@ -23,8 +23,7 @@ GetAvailableSlotForRegCentreId: output: '{ "errors": [ { - "errorCode": "KER-MSD-215", - "message": "Registration Center not found" + "errorCode": "KER-MSD-215" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml b/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml index 366ba1d8609..e0e56236373 100644 --- a/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml +++ b/automationtests/src/main/resources/preReg/GetPRIDByDateRange/GetPRIDByDateRange.yml @@ -33,8 +33,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -55,8 +54,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -77,8 +75,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -99,8 +96,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_002", - "message": "Request version is invalid" + "errorCode": "PRG_PAM_CORE_002" } ] }' @@ -121,8 +117,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_002", - "message": "Request version is invalid" + "errorCode": "PRG_PAM_CORE_002" } ] }' @@ -143,8 +138,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_002", - "message": "Request version is invalid" + "errorCode": "PRG_PAM_CORE_002" } ] }' @@ -228,8 +222,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_032", - "message": "Record not found for date range and reg center id" + "errorCode": "PRG_BOOK_RCI_032" } ] }' @@ -250,8 +243,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_DATA_SYNC_009", - "message": "registration center id is invalid" + "errorCode": "PRG_DATA_SYNC_009" } ] }' @@ -272,8 +264,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_DATA_SYNC_009", - "message": "registration center id is invalid" + "errorCode": "PRG_DATA_SYNC_009" } ] }' @@ -294,8 +285,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_019", - "message": "Invalid date time format" + "errorCode": "PRG_CORE_REQ_019" } ] }' @@ -316,8 +306,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_019", - "message": "Invalid date time format" + "errorCode": "PRG_CORE_REQ_019" } ] }' @@ -338,8 +327,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_019", - "message": "Invalid date time format" + "errorCode": "PRG_CORE_REQ_019" } ] }' @@ -360,8 +348,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_032", - "message": "Record not found for date range and reg center id" + "errorCode": "PRG_BOOK_RCI_032" } ] }' @@ -382,8 +369,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_032", - "message": "Record not found for date range and reg center id" + "errorCode": "PRG_BOOK_RCI_032" } ] }' @@ -404,8 +390,7 @@ GetPRIDByDateRange: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_019", - "message": "Invalid date time format" + "errorCode": "PRG_CORE_REQ_019" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetPRIDForRegCent/GetPRIDForRegCent.yml b/automationtests/src/main/resources/preReg/GetPRIDForRegCent/GetPRIDForRegCent.yml index 34a6e16ab64..0d317e60b4e 100644 --- a/automationtests/src/main/resources/preReg/GetPRIDForRegCent/GetPRIDForRegCent.yml +++ b/automationtests/src/main/resources/preReg/GetPRIDForRegCent/GetPRIDForRegCent.yml @@ -23,8 +23,7 @@ GetPRIDForRegCent: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_032", - "message": "Record not found for date range and reg center id" + "errorCode": "PRG_BOOK_RCI_032" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/GetPreRegInfoByPrid.yml b/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/GetPreRegInfoByPrid.yml index 96d3ea71729..dfbc75eb365 100644 --- a/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/GetPreRegInfoByPrid.yml +++ b/automationtests/src/main/resources/preReg/GetPreRegInfoByPrid/GetPreRegInfoByPrid.yml @@ -27,8 +27,7 @@ GetPreRegInfoByPrid: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml index ea03f2a7382..ff67fcaa8c2 100644 --- a/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml +++ b/automationtests/src/main/resources/preReg/GetSpecificDocumentforaPRID/GetSpecificDocumentforaPRID.yml @@ -26,8 +26,7 @@ GetSpecificDocumentforaPRID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' @@ -44,8 +43,7 @@ GetSpecificDocumentforaPRID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_DOC_005", - "message": "Documents is not found for the requested pre-registration id" + "errorCode": "PRG_PAM_DOC_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml b/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml index 05f78f8eaba..ac4ba56f9cf 100644 --- a/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml +++ b/automationtests/src/main/resources/preReg/GetUpdatedDateTimeByPrid/GetUpdatedDateTimeByPrid.yml @@ -45,8 +45,7 @@ GetUpdatedDateTimeByPrid: output: '{ "errors": [ { - "errorCode": "PRG_PAM_APP_005", - "message": "No data found for the requested pre-registration id" + "errorCode": "PRG_PAM_APP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/Transliteration/Translate.yml b/automationtests/src/main/resources/preReg/Transliteration/Translate.yml index 67e71f9bf40..c9c78174036 100644 --- a/automationtests/src/main/resources/preReg/Transliteration/Translate.yml +++ b/automationtests/src/main/resources/preReg/Transliteration/Translate.yml @@ -38,8 +38,7 @@ Transliteration: output: '{ "errors": [ { - "errorCode": "PRG_TRL_APP_002", - "message": "Unsupported language" + "errorCode": "PRG_TRL_APP_002" } ] }' @@ -61,8 +60,7 @@ Transliteration: output: '{ "errors": [ { - "errorCode": "PRG_TRL_APP_002", - "message": "Unsupported language" + "errorCode": "PRG_TRL_APP_002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml b/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml index 4550d8b8f14..234164c410f 100644 --- a/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml +++ b/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml @@ -2,6 +2,7 @@ UpdateDocRefID: Prereg_UpdateDocRefID_All_Valid_Smoke_POA_sid: endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} role: batch + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: preReg/UpdateDocRefID/updateDocRefID outputTemplate: preReg/UpdateDocRefID/updateDocRefIDResult @@ -11,11 +12,11 @@ UpdateDocRefID: "refNumber":"text" }' output: '{ - "errors": null }' Prereg_UpdateDocRefID_All_Valid_Smoke_POI_sid: endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} role: batch + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: preReg/UpdateDocRefID/updateDocRefID outputTemplate: preReg/UpdateDocRefID/updateDocRefIDResult @@ -25,11 +26,11 @@ UpdateDocRefID: "refNumber":"text" }' output: '{ - "errors": null }' Prereg_UpdateDocRefID_All_Valid_Smoke_POB_sid: endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} role: batch + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: preReg/UpdateDocRefID/updateDocRefID outputTemplate: preReg/UpdateDocRefID/updateDocRefIDResult @@ -39,11 +40,11 @@ UpdateDocRefID: "refNumber":"text" }' output: '{ - "errors": null }' Prereg_UpdateDocRefID_All_Valid_Smoke_POR_sid: endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} role: batch + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: preReg/UpdateDocRefID/updateDocRefID outputTemplate: preReg/UpdateDocRefID/updateDocRefIDResult @@ -53,7 +54,6 @@ UpdateDocRefID: "refNumber":"text" }' output: '{ - "errors": null }' Prereg_UpdateDocRefID_inValid_documentId: endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} @@ -69,8 +69,7 @@ UpdateDocRefID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_DOC_005", - "message": "Documents is not found for the requested pre-registration id" + "errorCode": "PRG_PAM_DOC_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs b/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs index 297ff8b24e5..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs +++ b/automationtests/src/main/resources/preReg/UpdateDocRefID/updateDocRefIDResult.hbs @@ -1,3 +1,2 @@ { - "errors": null } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatus.yml b/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatus.yml index 013f75af5e7..bc8c8e0fbe6 100644 --- a/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatus.yml +++ b/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatus.yml @@ -2,6 +2,7 @@ UpdatePreRegStatus: Prereg_UpdatePreRegStatus_All_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -10,11 +11,11 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' Prereg_UpdatePreRegStatus_All_Valid_Smoke_BookByPRID_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -23,11 +24,11 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' Prereg_UpdatePreRegStatus_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -36,11 +37,11 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' Prereg_UpdatePreRegStatus_CA_Valid_Smoke_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -49,11 +50,11 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' Prereg_UpdatePreRegStatus_Smoke_alldel_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -62,11 +63,11 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' Prereg_UpdatePreRegStatus_Smoke_CancellAppointment_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -75,11 +76,11 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' Prereg_UpdatePreRegStatus_Smoke_CancelApplicationsAppointment_sid: endPoint: /preregistration/v1/applications/prereg/status/{preRegistrationId}?statusCode={statusCode} role: batch + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatus outputTemplate: preReg/UpdatePreRegStatus/updatePreRegStatusResult @@ -88,5 +89,4 @@ UpdatePreRegStatus: "statusCode": "Pending_Appointment" }' output: '{ - "response": "STATUS_UPDATED_SUCESSFULLY" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs b/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs +++ b/automationtests/src/main/resources/preReg/UpdatePreRegStatus/updatePreRegStatusResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml b/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml index a5771d5a7c6..d78f141da63 100644 --- a/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml +++ b/automationtests/src/main/resources/preReg/UpdatePreregistration/UpdatePreregistration.yml @@ -62,8 +62,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "KER-IOV-004", - "message": "Invalid input parameter - identity/dateOfBirth" + "errorCode": "KER-IOV-004" } ] }' @@ -88,8 +87,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -114,8 +112,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -140,8 +137,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "KER-IOV-004", - "message": "Invalid input parameter - identity/email" + "errorCode": "KER-IOV-004" } ] }' @@ -166,8 +162,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_014", - "message": "Lang code is invalid" + "errorCode": "PRG_CORE_REQ_014" } ] }' @@ -192,8 +187,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_014", - "message": "Lang code is invalid" + "errorCode": "PRG_CORE_REQ_014" } ] }' @@ -268,8 +262,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_013", - "message": "Request date should be current date" + "errorCode": "PRG_CORE_REQ_013" } ] }' @@ -294,8 +287,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -320,8 +312,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -346,8 +337,7 @@ UpdatePreregistration: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml b/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml index 6623b052042..7613d01f354 100644 --- a/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml +++ b/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml @@ -2,6 +2,7 @@ ValidateOtp: Prereg_ValidateOtp_All_Valid_Smoke_Phone_sid: endPoint: /preregistration/v1/login/validateOtp role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/ValidateOtp/validateOtp outputTemplate: preReg/ValidateOtp/validateOtpResult @@ -13,11 +14,11 @@ ValidateOtp: "id": "mosip.pre-registration.login.useridotp" }' output: '{ - "status": "success" }' Prereg_SendOtp_All_Valid_Smoke_email_sid: endPoint: /preregistration/v1/login/validateOtp role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/ValidateOtp/validateOtp outputTemplate: preReg/ValidateOtp/validateOtpResult @@ -29,5 +30,4 @@ ValidateOtp: "id": "mosip.pre-registration.login.useridotp" }' output: '{ - "status": "success" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs b/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs index 0137f52daaa..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs +++ b/automationtests/src/main/resources/preReg/ValidateOtp/validateOtpResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "status": "{{status}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml index afbdbc8a1bd..148c06b401e 100644 --- a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml +++ b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointment.yml @@ -2,6 +2,7 @@ BookAppointment: Prereg_BookAppointment_All_Valid_Smoke: endPoint: /preregistration/v1/applications/appointment/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/bookAppointment/bookAppointment outputTemplate: preReg/bookAppointment/bookAppointmentResult @@ -16,11 +17,11 @@ BookAppointment: "requesttime": "$TIMESTAMP$" }' output: '{ - "langCode": "eng" }' Prereg_BookAppointment_CA_Smoke: endPoint: /preregistration/v1/applications/appointment/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/bookAppointment/bookAppointment outputTemplate: preReg/bookAppointment/bookAppointmentResult @@ -35,11 +36,11 @@ BookAppointment: "requesttime": "$TIMESTAMP$" }' output: '{ - "langCode": "eng" }' Prereg_BookAppointment_CancelApplicationsAppointment_Smoke: endPoint: /preregistration/v1/applications/appointment/{preRegistrationId} role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/bookAppointment/bookAppointment outputTemplate: preReg/bookAppointment/bookAppointmentResult @@ -54,7 +55,6 @@ BookAppointment: "requesttime": "$TIMESTAMP$" }' output: '{ - "langCode": "eng" }' Prereg_BookAppointment_inValid_preRegistrationId: endPoint: /preregistration/v1/applications/appointment/{preRegistrationId} @@ -75,8 +75,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' @@ -123,8 +122,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -171,8 +169,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -195,8 +192,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -219,8 +215,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -339,8 +334,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_008", - "message": "Booking date time not selected" + "errorCode": "PRG_BOOK_RCI_008" } ] }' @@ -387,8 +381,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -411,8 +404,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -435,8 +427,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -459,8 +450,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -483,8 +473,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -507,8 +496,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -531,8 +519,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_003", - "message": "Invalid request time" + "errorCode": "PRG_CORE_REQ_003" } ] }' @@ -579,8 +566,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_003", - "message": "Invalid request time" + "errorCode": "PRG_CORE_REQ_003" } ] }' @@ -603,8 +589,7 @@ BookAppointment: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_013", - "message": "Request date should be current date" + "errorCode": "PRG_CORE_REQ_013" } ] }' diff --git a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs index aac4a1fba68..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs +++ b/automationtests/src/main/resources/preReg/bookAppointment/bookAppointmentResult.hbs @@ -1,6 +1,2 @@ { - - "response": { - "bookingMessage": "Appointment booked successfully" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml index 4a763528275..1816a11e5e6 100644 --- a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml +++ b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRID.yml @@ -2,6 +2,7 @@ BookAppointmentByPRID: Prereg_BookAppointmentByPRID_All_Valid_Smoke: endPoint: /preregistration/v1/applications/appointment role: batch + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: preReg/bookAppointmentByPRID/bookAppointmentByPRID outputTemplate: preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult @@ -16,7 +17,6 @@ BookAppointmentByPRID: "requesttime": "$TIMESTAMP$" }' output: '{ - "bookingMessage": "Appointment booked successfully" }' Prereg_BookAppointmentByPRID_inValid_preRegistrationId: endPoint: /preregistration/v1/applications/appointment @@ -37,8 +37,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' @@ -61,8 +60,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' @@ -85,8 +83,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_APP_013", - "message": "No Records Found" + "errorCode": "PRG_APP_013" } ] }' @@ -109,8 +106,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -133,8 +129,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -157,8 +152,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -181,8 +175,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -205,8 +198,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -229,8 +221,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "KER-MSD-215", - "message": "Registration Center not found" + "errorCode": "KER-MSD-215" } ] }' @@ -253,8 +244,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_007", - "message": "Registration center id not entered" + "errorCode": "PRG_BOOK_RCI_007" } ] }' @@ -277,8 +267,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_007", - "message": "Registration center id not entered" + "errorCode": "PRG_BOOK_RCI_007" } ] }' @@ -301,8 +290,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_008", - "message": "Booking date time not selected" + "errorCode": "PRG_BOOK_RCI_008" } ] }' @@ -325,8 +313,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_008", - "message": "Booking date time not selected" + "errorCode": "PRG_BOOK_RCI_008" } ] }' @@ -373,8 +360,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -397,8 +383,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -421,8 +406,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -445,8 +429,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_BOOK_RCI_003", - "message": "User has not selected time slot" + "errorCode": "PRG_BOOK_RCI_003" } ] }' @@ -469,8 +452,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_003", - "message": "Invalid request time" + "errorCode": "PRG_CORE_REQ_003" } ] }' @@ -517,8 +499,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_003", - "message": "Invalid request time" + "errorCode": "PRG_CORE_REQ_003" } ] }' @@ -541,8 +522,7 @@ BookAppointmentByPRID: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_013", - "message": "Request date should be current date" + "errorCode": "PRG_CORE_REQ_013" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs index 9fb6fa8707e..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs +++ b/automationtests/src/main/resources/preReg/bookAppointmentByPRID/bookAppointmentByPRIDResult.hbs @@ -1,9 +1,2 @@ { - "response": { - "bookingStatusResponse": [ - { - "bookingMessage": "{{bookingMessage}}" - } - ] - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml index c2be19e4338..f3238dbe017 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml +++ b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml @@ -160,8 +160,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -185,8 +184,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -210,8 +208,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_PAM_CORE_001", - "message": "Request id is invalid" + "errorCode": "PRG_PAM_CORE_001" } ] }' @@ -235,8 +232,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_014", - "message": "Lang code is invalid" + "errorCode": "PRG_CORE_REQ_014" } ] }' @@ -260,8 +256,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_014", - "message": "Lang code is invalid" + "errorCode": "PRG_CORE_REQ_014" } ] }' @@ -285,8 +280,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "KER-IOV-004", - "message": "Invalid input parameter - identity/email" + "errorCode": "KER-IOV-004" } ] }' @@ -334,8 +328,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_003", - "message": "Invalid request time" + "errorCode": "PRG_CORE_REQ_003" } ] }' @@ -359,8 +352,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_013", - "message": "Request date should be current date" + "errorCode": "PRG_CORE_REQ_013" } ] }' @@ -384,8 +376,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' @@ -409,8 +400,7 @@ CreatePrereg: output: '{ "errors": [ { - "errorCode": "PRG_CORE_REQ_002", - "message": "Request version is invalid" + "errorCode": "PRG_CORE_REQ_002" } ] }' \ No newline at end of file From f738f04ea5715453e1f0086c6544757308c6cf32 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 29 Aug 2023 09:36:05 +0530 Subject: [PATCH 087/204] MOSIP-29106 --- .../apirig/admin/fw/util/AdminTestUtil.java | 8 +- .../testrig/apirig/dbaccess/DBManager.java | 6 +- .../apirig/kernel/util/CommonLibrary.java | 2 +- .../apirig/kernel/util/ConfigManager.java | 6 +- .../kernel/util/KeycloakUserManager.java | 2 +- .../testrig/apirig/service/BaseTestCase.java | 4 +- .../apirig/testrunner/HealthChecker.java | 2 +- .../apirig/testrunner/MosipTestRunner.java | 118 ++++++++++-------- 8 files changed, 83 insertions(+), 65 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index ac432d290cf..9b014e3fb86 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -128,14 +128,14 @@ public class AdminTestUtil extends BaseTestCase { private static final Logger logger = Logger.getLogger(AdminTestUtil.class); protected static final Properties properties = getproperty( - MosipTestRunner.getResourcePath() + "/" + "config/application.properties"); + MosipTestRunner.getGlobalResourcePath() + "/" + "config/application.properties"); protected static final Properties propsMap = getproperty( - MosipTestRunner.getResourcePath() + "/" + "config/valueMapping.properties"); + MosipTestRunner.getGlobalResourcePath() + "/" + "config/valueMapping.properties"); protected static final Properties propsBio = getproperty( MosipTestRunner.getGlobalResourcePath() + "/" + "config/bioValue.properties"); protected static final Properties propsKernel = getproperty( - MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); - public static String propsHealthCheckURL = MosipTestRunner.getResourcePath() + "/" + MosipTestRunner.getGlobalResourcePath() + "/" + "config/Kernel.properties"); + public static String propsHealthCheckURL = MosipTestRunner.getGlobalResourcePath() + "/" + "config/healthCheckEndpoint.properties"; private static String serverComponentsCommitDetails; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/DBManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/DBManager.java index 7fa1adbbccb..3a6cb0b8eba 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/DBManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/DBManager.java @@ -24,7 +24,7 @@ public static void clearPMSDbData() { try { session = getDataBaseConnection(ConfigManager.getPMSDbUrl(), ConfigManager.getPMSDbUser(), ConfigManager.getPMSDbPass(), ConfigManager.getPMSDbSchema()); - executeQueries(session, MosipTestRunner.getResourcePath() + "/" + "config/pmsDataDeleteQueries.txt"); + executeQueries(session, MosipTestRunner.getGlobalResourcePath() + "/" + "config/pmsDataDeleteQueries.txt"); } catch (Exception e) { logger.error("Error:: While executing PMS DB Quiries." + e.getMessage()); } finally { @@ -38,7 +38,7 @@ public static void clearKeyManagerDbData() { try { session = getDataBaseConnection(ConfigManager.getKMDbUrl(), ConfigManager.getKMDbUser(), ConfigManager.getKMDbPass(), ConfigManager.getKMDbSchema()); - executeQueries(session, MosipTestRunner.getResourcePath() + "/" + "config/keyManagerDataDeleteQueries.txt"); + executeQueries(session, MosipTestRunner.getGlobalResourcePath() + "/" + "config/keyManagerDataDeleteQueries.txt"); } catch (Exception e) { logger.error("Error:: While executing PMS DB Quiries." + e.getMessage()); } finally { @@ -52,7 +52,7 @@ public static void clearMasterDbData() { try { session = getDataBaseConnection(ConfigManager.getMASTERDbUrl(), ConfigManager.getMasterDbUser(), ConfigManager.getMasterDbPass(), ConfigManager.getMasterDbSchema()); - executeQueries(session, MosipTestRunner.getResourcePath() + "/" + "config/masterDataDeleteQueries.txt"); + executeQueries(session, MosipTestRunner.getGlobalResourcePath() + "/" + "config/masterDataDeleteQueries.txt"); } catch (Exception e) { logger.error("Error:: While executing MASTER DB Quiries." + e.getMessage()); } finally { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index 5cdae236dc4..16c3439fba9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -129,7 +129,7 @@ public String getResourcePath() { } public String getResourcePathForKernel() { - return MosipTestRunner.getResourcePath() + "/"; + return MosipTestRunner.getGlobalResourcePath() + "/"; } public JSONObject readJsonData(String path, boolean isRelative) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index 096d8bdf2f9..0666f90b799 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -234,7 +234,7 @@ public static String getValueForKey(String key) { } public static void init() { - propsKernel = getproperty(MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); + propsKernel = getproperty(MosipTestRunner.getGlobalResourcePath() + "/" + "config/Kernel.properties"); pms_client_secret = getValueForKey(MOSIP_PMS_CLIENT_SECRET); partner_client_secret = getValueForKey(MOSIP_PARTNER_CLIENT_SECRET); @@ -476,7 +476,7 @@ public static String getauthCertsPath() { } public static Properties init(String abc) { - propsKernel = getproperty(MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); + propsKernel = getproperty(MosipTestRunner.getGlobalResourcePath() + "/" + "config/Kernel.properties"); return propsKernel; } @@ -741,7 +741,7 @@ public static String getIAMUsersPassword() { } public static String getRolesForUser(String userId) { - propsKernel = getproperty(MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); + propsKernel = getproperty(MosipTestRunner.getGlobalResourcePath() + "/" + "config/Kernel.properties"); return propsKernel.getProperty("roles." + userId); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java index f8f14a3c51a..d7e2104d405 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java @@ -33,7 +33,7 @@ public class KeycloakUserManager { private static final Logger logger = Logger.getLogger(KeycloakUserManager.class); - public static Properties propsKernel = getproperty(MosipTestRunner.getResourcePath() + "/"+"config/Kernel.properties"); + public static Properties propsKernel = getproperty(MosipTestRunner.getGlobalResourcePath() + "/"+"config/Kernel.properties"); public static Keycloak key = null; public static void closeKeycloakInstance() { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index ad7afc44964..b7bf3fade0d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -169,9 +169,9 @@ public class BaseTestCase { public static String clientAssertionToken; private static String zoneMappingRequest = "config/Authorization/zoneMappingRequest.json"; public static Properties props = getproperty( - MosipTestRunner.getResourcePath() + "/" + "config/application.properties"); + MosipTestRunner.getGlobalResourcePath() + "/" + "config/application.properties"); public static Properties propsKernel = getproperty( - MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); + MosipTestRunner.getGlobalResourcePath() + "/" + "config/Kernel.properties"); public static String currentRunningLanguage = ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java index 7ce5f335c56..a6c146732d3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java @@ -33,7 +33,7 @@ public HealthChecker() { private static final Logger logger = Logger.getLogger(HealthChecker.class); public static boolean bTerminate = false; - public static String propsHealthCheckURL = MosipTestRunner.getResourcePath() + "/" + public static String propsHealthCheckURL = MosipTestRunner.getGlobalResourcePath() + "/" + "config/healthCheckEndpoint.properties"; public static boolean signalTerminateExecution = false; public static Map healthCheckFailureMapS = Collections diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 055e296e49e..48a6df0ba18 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -44,8 +44,7 @@ */ public class MosipTestRunner { private static final Logger LOGGER = Logger.getLogger(MosipTestRunner.class); - - + private static String cachedPath = null; public static String jarUrl = MosipTestRunner.class.getProtectionDomain().getCodeSource().getLocation().getPath(); public static List languageList = new ArrayList<>(); @@ -70,11 +69,11 @@ public static void main(String[] arg) { } else { ExtractResource.copyCommonResources(); } - ConfigManager.init(); + ConfigManager.init(); BaseTestCase.suiteSetup(); setLogLevels(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); - + // For now we are not doing health check for qa-115. if (BaseTestCase.isTargetEnvLTS()) { HealthChecker healthcheck = new HealthChecker(); @@ -85,8 +84,7 @@ public static void main(String[] arg) { KeycloakUserManager.removeUser(); KeycloakUserManager.createUsers(); KeycloakUserManager.closeKeycloakInstance(); - - + List localLanguageList = new ArrayList<>(BaseTestCase.getLanguageList()); AdminTestUtil.getLocationData(); @@ -101,11 +99,8 @@ public static void main(String[] arg) { } - - - if (BaseTestCase.listOfModules.contains(GlobalConstants.MASTERDATA)) { - + AdminTestUtil.getLocationLevelData(); AdminTestUtil.getLocationData(); BaseTestCase.mapUserToZone(); @@ -136,15 +131,15 @@ public static void main(String[] arg) { } MockSMTPListener.bTerminate = true; - + if (BaseTestCase.isTargetEnvLTS()) HealthChecker.bTerminate = true; System.exit(0); } - - private static void setLogLevels(){ + + private static void setLogLevels() { AdminTestUtil.setLogLevel(); OutputValidationUtil.setLogLevel(); PartnerRegistration.setLogLevel(); @@ -167,8 +162,7 @@ public static void startTestRunner() { if (checkRunType().contains("IDE") || os.toLowerCase().contains("windows")) { homeDir = new File(System.getProperty("user.dir") + "/testNgXmlFiles"); LOGGER.info("IDE :" + homeDir); - } - else { + } else { File dir = new File(System.getProperty("user.dir")); homeDir = new File(dir.getParent() + "/mosip/testNgXmlFiles"); LOGGER.info("ELSE :" + homeDir); @@ -194,16 +188,40 @@ public static void startTestRunner() { * @return String * @throws IOException */ + /* + * public static String getGlobalResourcePath() { if + * (checkRunType().equalsIgnoreCase("JAR")) { return new + * File(jarUrl).getParentFile().getAbsolutePath() + + * "/MosipTestResource/MosipTemporaryTestResource"; } else if + * (checkRunType().equalsIgnoreCase("IDE")) { String path = new + * File(MosipTestRunner.class.getClassLoader().getResource("").getPath()). + * getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; if + * (path.contains(GlobalConstants.TESTCLASSES)) path = + * path.replace(GlobalConstants.TESTCLASSES, "classes"); return path; } return + * "Global Resource File Path Not Found"; } + */ + public static String getGlobalResourcePath() { + if (cachedPath != null) { + return cachedPath; + } + + String path = null; if (checkRunType().equalsIgnoreCase("JAR")) { - return new File(jarUrl).getParentFile().getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; + path = new File(jarUrl).getParentFile().getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; } else if (checkRunType().equalsIgnoreCase("IDE")) { - String path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath() + "/MosipTestResource/MosipTemporaryTestResource"; + path = new File(MosipTestRunner.class.getClassLoader().getResource("").getPath()).getAbsolutePath() + + "/MosipTestResource/MosipTemporaryTestResource"; if (path.contains(GlobalConstants.TESTCLASSES)) path = path.replace(GlobalConstants.TESTCLASSES, "classes"); + } + + if (path != null) { + cachedPath = path; return path; + } else { + return "Global Resource File Path Not Found"; } - return "Global Resource File Path Not Found"; } public static String getResourcePath() { @@ -218,7 +236,7 @@ public static String getResourcePath() { // } // return "Global Resource File Path Not Found"; } - + public static String generatePulicKey() { String publicKey = null; try { @@ -231,8 +249,9 @@ public static String generatePulicKey() { } return publicKey; } + public static KeyPairGenerator keyPairGen = null; - + public static KeyPairGenerator getKeyPairGeneratorInstance() { if (keyPairGen != null) return keyPairGen; @@ -246,31 +265,31 @@ public static KeyPairGenerator getKeyPairGeneratorInstance() { return keyPairGen; } - + public static String generatePublicKeyForMimoto() { - - String vcString = ""; - try { - KeyPairGenerator keyPairGenerator = getKeyPairGeneratorInstance(); - KeyPair keyPair = keyPairGenerator.generateKeyPair(); - PublicKey publicKey = keyPair.getPublic(); - StringWriter stringWriter = new StringWriter(); - try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) { - pemWriter.writeObject(publicKey); - pemWriter.flush(); - vcString = stringWriter.toString(); - if (System.getProperty("os.name").toLowerCase().contains("windows")) { - vcString = vcString.replaceAll("\r\n", "\\\\n"); - } else { - vcString = vcString.replaceAll("\n", "\\\\n"); - } - } catch (Exception e) { - throw e; - } - } catch (Exception e) { - LOGGER.error(e.getMessage()); - } - return vcString; + + String vcString = ""; + try { + KeyPairGenerator keyPairGenerator = getKeyPairGeneratorInstance(); + KeyPair keyPair = keyPairGenerator.generateKeyPair(); + PublicKey publicKey = keyPair.getPublic(); + StringWriter stringWriter = new StringWriter(); + try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) { + pemWriter.writeObject(publicKey); + pemWriter.flush(); + vcString = stringWriter.toString(); + if (System.getProperty("os.name").toLowerCase().contains("windows")) { + vcString = vcString.replaceAll("\r\n", "\\\\n"); + } else { + vcString = vcString.replaceAll("\n", "\\\\n"); + } + } catch (Exception e) { + throw e; + } + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + return vcString; } public static String generateJWKPublicKey() { @@ -278,17 +297,16 @@ public static String generateJWKPublicKey() { KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance("RSA"); keyGenerator.initialize(2048, BaseTestCase.secureRandom); final KeyPair keypair = keyGenerator.generateKeyPair(); - RSAKey jwk = new RSAKey.Builder((RSAPublicKey) keypair.getPublic()).keyID("RSAKeyID").keyUse(KeyUse.SIGNATURE) - .privateKey(keypair.getPrivate()) - .build(); - + RSAKey jwk = new RSAKey.Builder((RSAPublicKey) keypair.getPublic()).keyID("RSAKeyID") + .keyUse(KeyUse.SIGNATURE).privateKey(keypair.getPrivate()).build(); + return jwk.toJSONString(); } catch (NoSuchAlgorithmException e) { LOGGER.error(e.getMessage()); return null; } } - + public static Properties getproperty(String path) { Properties prop = new Properties(); FileInputStream inputStream = null; @@ -298,7 +316,7 @@ public static Properties getproperty(String path) { prop.load(inputStream); } catch (Exception e) { LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); - }finally { + } finally { AdminTestUtil.closeInputStream(inputStream); } return prop; From 2c1ba2a1c9e1881b320319ce0255dbf53744ff01 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 29 Aug 2023 10:21:36 +0530 Subject: [PATCH 088/204] MOSIP-29086 --- .../ActivateDeactivatePartner.yml | 7 +-- .../activateDeactivatePartnerResult.hbs | 3 - .../ActivateDeactivatePartnerApiKey.yml | 12 ++-- .../activateDeactivatePartnerApiKeyResult.hbs | 1 - .../CreateBioExtractors.yml | 4 +- .../DeviceDetailsFilter.yml | 9 +-- .../DeviceSubTypeFilter.yml | 9 +-- .../DeviceTypeFilter/DeviceTypeFilter.yml | 17 +++-- .../PartnerApiKeyRequestFilter.yml | 9 +-- .../PartnerFilter/PartnerFilter.yml | 17 +++-- .../PolicyGroupFilter/PolicyGroupFilter.yml | 14 +++-- .../ApproveAPIKey/ApproveAPIKey.yml | 2 +- .../ApproveAPIKey/approveAPIKeyResult.hbs | 1 - .../GetPartnerApiKeyRequest.yml | 4 +- .../partner/GetPartners/GetPartners.yml | 3 +- .../GetPartnersPolicy/GetPartnersPolicy.yml | 3 +- .../GetPolicyForApiKey/GetPolicyForApiKey.yml | 6 +- ...olicyforMappedPartnerAndCredentialtype.yml | 6 +- .../GetValueForConfigKey.yml | 2 + .../getValueForConfigKeyResult.hbs | 4 -- .../MapPartnerAndPolicytoCredentialType.yml | 9 ++- ...PartnerAndPolicytoCredentialTypeResult.hbs | 1 - .../CreateMispLicense/CreateMispLicense.yml | 3 +- .../FilterMispLicense/FilterMispLicense.yml | 9 +-- .../GetMISPLicenseByMispID.yml | 6 +- .../SearchMispLicense/SearchMispLicense.yml | 15 ++--- .../UpdateMispLicense/UpdateMispLicense.yml | 3 +- .../partner/PartnerSearch/partnerSearch.yml | 62 +++++-------------- .../GetPartnerDetails/GetPartnerDetails.yml | 1 + .../PrintPartner/UploadCert/UploadCert.yml | 1 + .../createSearchDeviceType.yml | 18 ++---- .../SearchPartner/createSearchPartner.yml | 21 +++---- .../SearchPartnerApiKey.yml | 12 ++-- .../SearchPartnerApiRequestKey.yml | 6 +- .../searchPartnerApiRequestKeyResult.hbs | 3 +- .../createSearchPartnerType.yml | 35 ++++++----- .../SearchPolicy/createSearchPolicy.yml | 23 ++++--- .../createSearchPolicyGroup.yml | 16 ++--- .../createSearchPolicyGroupResult.hbs | 10 --- .../createSearchRegisteredDevice.yml | 30 +++------ .../createSearchSecureBiometric.yml | 3 + .../UpdatePolicyAgainstApiKey.yml | 14 ++--- .../updatePolicyAgainstApiKeyResult.hbs | 3 - .../UpdatePolicyGroupForPartner.yml | 12 ++-- .../APIKeyAutoApproval/APIKeyAutoApproval.yml | 4 +- .../apiKeyAutoApprovalResult.hbs | 3 - .../authPartner/AddContacts/AddContact.yml | 8 +-- .../AddContacts/addContactResult.hbs | 1 - .../ApproveAPIKey/ApproveAPIKey.yml | 5 +- .../ApproveAPIKey/approveAPIKeyResult.hbs | 1 - .../CreatePartner/CreatePartner.yml | 12 ++-- .../authPartner/GetCertificate/GetCert.yml | 6 +- .../authPartner/GetPartner/GetPartner.yml | 3 +- .../authPartner/RejectAPIKey/RejectAPIKey.yml | 5 +- .../RejectAPIKey/rejectAPIKeyResult.hbs | 1 - .../RequestAPIKey/RequestAPIKey.yml | 7 +-- .../RequestAPIKey/requestAPIKeyResult.hbs | 3 - .../UpdatePartner/UpdatePartner.yml | 9 +-- .../UploadCertificate/UploadCertificate.yml | 2 +- .../uploadCertificateResult.hbs | 3 - .../APIKeyAutoApproval/APIKeyAutoApproval.yml | 1 - .../apiKeyAutoApprovalResult.hbs | 3 - .../AddBioExtractors/AddBioExtractors.yml | 10 ++- .../addBioExtractorsResult.hbs | 1 - .../ApproveAPIKey/ApproveAPIKey.yml | 4 +- .../ApproveAPIKey/approveAPIKeyResult.hbs | 1 - .../GetPartner/GetPartner.yml | 3 +- .../RejectAPIKey/RejectAPIKey.yml | 5 +- .../RejectAPIKey/rejectAPIKeyResult.hbs | 1 - .../RequestAPIKey/RequestAPIKey.yml | 4 +- .../RequestAPIKey/requestAPIKeyResult.hbs | 2 - .../UploadCert/uploadCertResult.hbs | 2 - .../UploadCertificate/UploadCertificate.yml | 4 +- .../uploadCertificateResult.hbs | 3 - .../MapDeviceWithSBI/MapDeviceWithSBI.yml | 4 +- .../mapDeviceWithSBIResult.hbs | 1 - .../ApproveSecureBiometricInterface.yml | 6 +- .../approveSecureBiometricInterfaceResult.hbs | 1 - .../create/CreateSecureBiometricInterface.yml | 5 +- .../reject/RejectSecureBiometricInterface.yml | 7 +-- .../rejectSecureBiometricInterfaceResult.hbs | 1 - .../update/UpdateSecureBiometricInterface.yml | 5 +- .../deregistration/DeRegisterDevice.yml | 2 +- .../approve/ApproveFtpChipDetail.yml | 5 +- .../approve/approveFtpChipDetailResult.hbs | 3 - .../create/CreateFTPChipDetail.yml | 7 +-- .../ftmChipDetails/get/GetFtpChipDetail.yml | 1 + .../reject/RejectFtpChipDetail.yml | 3 +- .../reject/rejectFtpChipDetailResult.hbs | 1 - .../update/UpdateFtpChipDetail.yml | 3 +- .../update/updateFtpChipDetailResult.hbs | 3 - .../uploadcert/Uploadcertificate.yml | 7 +-- .../approve/ApproveDeviceDetail.yml | 8 +-- .../approve/approveDeviceDetailResult.hbs | 1 - .../create/CreateDeviceDetail.yml | 11 ++-- .../reject/RejectDeviceDetail.yml | 10 ++- .../reject/rejectDeviceDetailResult.hbs | 1 - .../update/UpdateDeviceDetail.yml | 12 ++-- .../device/registration/RegistereDevice.yml | 5 +- .../devicePartner/GetCertificate/GetCert.yml | 3 +- .../devicePartner/GetPartner/GetPartner.yml | 3 +- .../UploadCert/uploadCertResult.hbs | 2 - .../UploadCertificate/UploadCertificate.yml | 4 +- .../uploadCertificateResult.hbs | 3 - .../UploadCertificate/UploadCertificate.yml | 4 +- .../uploadCertificateResult.hbs | 3 - .../DefineDataSharePolicy.yml | 24 +++---- .../policy/DefinePolicy/DefinePolicy.yml | 33 ++++------ .../definePolicyGroupResult.hbs | 2 +- .../policy/GetPolicy/getPolicyResult.hbs | 2 +- .../policy/GetPolicyGroup/GetPolicyGroup.yml | 3 +- .../PublishDataSharePolicy.yml | 9 +-- .../policy/PublishPolicy/PublishPolicy.yml | 9 +-- .../partner/policy/Search/SearchPolicy.yml | 9 ++- .../UpdatePolicy/updatePolicyResult.hbs | 2 +- 115 files changed, 300 insertions(+), 494 deletions(-) diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartner/ActivateDeactivatePartner.yml b/automationtests/src/main/resources/partner/ActivateDeactivatePartner/ActivateDeactivatePartner.yml index e0749026fe6..2ec6761bd27 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartner/ActivateDeactivatePartner.yml +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartner/ActivateDeactivatePartner.yml @@ -2,6 +2,7 @@ ActivateDeactivatePartner: Partner_ActivateDeactivatePartner_deactivate_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId} role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/ActivateDeactivatePartner/activateDeactivatePartner outputTemplate: partner/ActivateDeactivatePartner/activateDeactivatePartnerResult @@ -11,11 +12,11 @@ ActivateDeactivatePartner: "status": "De-Active" }' output: '{ - "message": "Partner de-activated successfully" }' Partner_ActivateDeactivatePartner_activate_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId} role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/ActivateDeactivatePartner/activateDeactivatePartner outputTemplate: partner/ActivateDeactivatePartner/activateDeactivatePartnerResult @@ -25,7 +26,6 @@ ActivateDeactivatePartner: "status": "Active" }' output: '{ - "message": "Partner activated successfully" }' Partner_ActivateDeactivatePartner_invalid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId} @@ -41,8 +41,7 @@ ActivateDeactivatePartner: output: '{ "errors": [ { - "errorCode": "PMS_PMP_005", - "message": "Partner ID does not exist" + "errorCode": "PMS_PMP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs b/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartner/activateDeactivatePartnerResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml index 593421a578d..7f13b239361 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml @@ -2,6 +2,7 @@ ActivateDeactivatePartnerApiKey: Partner_ActivateDeactivatePartnerApiKey_deactivate_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/policy/{policyId}/apiKey/status role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKey outputTemplate: partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult @@ -13,11 +14,11 @@ ActivateDeactivatePartnerApiKey: "status": "De-Active" }' output: '{ - "response": "Partner apikey de-activated successfully." }' Partner_ActivateDeactivatePartnerApiKey_activate_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/policy/{policyId}/apiKey/status role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKey outputTemplate: partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult @@ -47,8 +48,7 @@ ActivateDeactivatePartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PRT_111", - "message": "API key not exists for the given combination" + "errorCode": "PMS_PRT_111" } ] }' @@ -68,8 +68,7 @@ ActivateDeactivatePartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PRT_111", - "message": "API key not exists for the given combination" + "errorCode": "PMS_PRT_111" } ] }' @@ -89,8 +88,7 @@ ActivateDeactivatePartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PRT_111", - "message": "API key not exists for the given combination" + "errorCode": "PMS_PRT_111" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKeyResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/CreateBioExtractors/CreateBioExtractors.yml b/automationtests/src/main/resources/partner/CreateBioExtractors/CreateBioExtractors.yml index 9dbdbdd6dcd..ac90c3f5796 100644 --- a/automationtests/src/main/resources/partner/CreateBioExtractors/CreateBioExtractors.yml +++ b/automationtests/src/main/resources/partner/CreateBioExtractors/CreateBioExtractors.yml @@ -2,6 +2,7 @@ CreateBioExtractors: Partner_CreateBioExtractors_InValid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/bioextractors/{policyId} role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/CreateBioExtractors/createBioExtractors outputTemplate: partner/error @@ -17,8 +18,7 @@ CreateBioExtractors: output: '{ "errors": [ { - "errorCode": "PMS_PRT_061", - "message": "Partner policy mapping not exists." + "errorCode": "PMS_PRT_061" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml index 69ad8a5dc55..24cad442d73 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml @@ -55,8 +55,7 @@ DeviceDetailsFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-322", - "message": "Filter Type cannot be empty or null" + "errorCode": "PMS-MSD-322" } ] }' @@ -78,8 +77,7 @@ DeviceDetailsFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' @@ -123,8 +121,7 @@ DeviceDetailsFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-324", - "message": "Received Filter Type not supported" + "errorCode": "PMS-MSD-324" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml index c9f0628d337..b37ef876fb5 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml @@ -53,8 +53,7 @@ DeviceSubTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-322", - "message": "Filter Type cannot be empty or null" + "errorCode": "PMS-MSD-322" } ] }' @@ -76,8 +75,7 @@ DeviceSubTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' @@ -99,8 +97,7 @@ DeviceSubTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-324", - "message": "Received Filter Type not supported" + "errorCode": "PMS-MSD-324" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml index 93263e0a4c6..284c77a4d26 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml @@ -15,9 +15,13 @@ DeviceTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ + "filters": [ + { "fieldID": "code", "fieldValue": "Finger", "fieldCode": "Finger" + } + ] }' partner_DeviceTypeFilter_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/deviceType/filtervalues @@ -35,9 +39,13 @@ DeviceTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ + "filters": [ + { "fieldID": "code", "fieldValue": "Finger", "fieldCode": "Finger" + } + ] }' partner_DeviceTypeFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/devicedetail/deviceType/filtervalues @@ -57,8 +65,7 @@ DeviceTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-322", - "message": "Filter Type cannot be empty or null" + "errorCode": "PMS-MSD-322" } ] }' @@ -80,8 +87,7 @@ DeviceTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' @@ -125,8 +131,7 @@ DeviceTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-324", - "message": "Received Filter Type not supported" + "errorCode": "PMS-MSD-324" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml index bf3a4122045..dffe107af2e 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml @@ -62,8 +62,7 @@ PartnerApiKeyRequestFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-322", - "message": "Filter Type cannot be empty or null" + "errorCode": "PMS-MSD-322" } ] }' @@ -84,8 +83,7 @@ PartnerApiKeyRequestFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' @@ -127,8 +125,7 @@ PartnerApiKeyRequestFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-324", - "message": "Received Filter Type not supported" + "errorCode": "PMS-MSD-324" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml index 2f04c6a3a95..e6d0ddc0d3c 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml @@ -14,9 +14,13 @@ PartnerFilter: "requesttime": "$TIMESTAMP$" }' output: '{ + "filters": [ + { "fieldID": "id", "fieldValue": "mpartner-default-abis", "fieldCode": "mpartner-default-abis" + } + ] }' partner_PartnerFilter_all_Valid_Smoke: endPoint: /v1/partnermanager/partners/filtervalues @@ -33,9 +37,13 @@ PartnerFilter: "requesttime": "$TIMESTAMP$" }' output: '{ + "filters": [ + { "fieldID": "id", "fieldValue": "mpartner-default-abis", "fieldCode": "mpartner-default-abis" + } + ] }' partner_PartnerFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/partners/filtervalues @@ -54,8 +62,7 @@ PartnerFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-322", - "message": "Filter Type cannot be empty or null" + "errorCode": "PMS-MSD-322" } ] }' @@ -97,8 +104,7 @@ PartnerFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-324", - "message": "Received Filter Type not supported" + "errorCode": "PMS-MSD-324" } ] }' @@ -119,8 +125,7 @@ PartnerFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml index 8f2c2b35b10..5b843c83b77 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml @@ -14,9 +14,13 @@ PolicyGroupFilter: "requesttime": "$TIMESTAMP$" }' output: '{ + "filters": [ + { "fieldID": "name", "fieldValue": "update_policy_group", "fieldCode": "update_policy_group" + } + ] }' partner_PolicyGroupFilter_all_Valid_Smoke: endPoint: /v1/policymanager/policies/group/filtervalues @@ -33,9 +37,13 @@ PolicyGroupFilter: "requesttime": "$TIMESTAMP$" }' output: '{ + "filters": [ + { "fieldID": "name", "fieldValue": "mpolicygroup-default-auth", "fieldCode": "mpolicygroup-default-auth" + } + ] }' partner_PolicyGroupFilter_using_desc_Valid_Smoke: endPoint: /v1/policymanager/policies/group/filtervalues @@ -99,8 +107,7 @@ PolicyGroupFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' @@ -121,8 +128,7 @@ PolicyGroupFilter: output: '{ "errors": [ { - "errorCode": "PMS_COR_003", - "message": "Could not process the request" + "errorCode": "PMS_COR_003" } ] }' diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/ApproveAPIKey.yml b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/ApproveAPIKey.yml index 1413d538184..e404336222e 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/ApproveAPIKey.yml +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/ApproveAPIKey.yml @@ -2,6 +2,7 @@ ApproveAPIKey: Partner_ApproveRejectPartnerAPIKeyReq_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/policy/{mappingkey} role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKey outputTemplate: partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult @@ -11,5 +12,4 @@ ApproveAPIKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Policy mapping approved successfully" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml b/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml index ccc96d71c19..bd8947b8d1f 100644 --- a/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml +++ b/automationtests/src/main/resources/partner/GetPartnerApiKeyRequest/GetPartnerApiKeyRequest.yml @@ -2,6 +2,7 @@ GetPartnerApiKeyRequest: Partner_GetPartnerApiKeyRequest_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/apikey/request role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetPartnerApiKeyRequest/getPartnerApiKeyRequest outputTemplate: partner/GetPartnerApiKeyRequest/getPartnerApiKeyRequestResult @@ -22,8 +23,7 @@ GetPartnerApiKeyRequest: output: '{ "errors": [ { - "errorCode": "PMS_PRT_006", - "message": "No api key req exist" + "errorCode": "PMS_PRT_006" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml b/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml index 974259c3248..19d9ff88aab 100644 --- a/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml +++ b/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml @@ -32,8 +32,7 @@ GetPartners: output: '{ "errors": [ { - "errorCode": "PMS_PMP_013", - "message": "Partner does not exist" + "errorCode": "PMS_PMP_013" } ] }' diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml index 92da4c83dd5..dbbd8ebfc3d 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml @@ -33,8 +33,7 @@ GetPartnersPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_017", - "message": "No policy available for given partner" + "errorCode": "PMS_POL_017" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPolicyForApiKey/GetPolicyForApiKey.yml b/automationtests/src/main/resources/partner/GetPolicyForApiKey/GetPolicyForApiKey.yml index aa85735c436..742b4465d7c 100644 --- a/automationtests/src/main/resources/partner/GetPolicyForApiKey/GetPolicyForApiKey.yml +++ b/automationtests/src/main/resources/partner/GetPolicyForApiKey/GetPolicyForApiKey.yml @@ -25,8 +25,7 @@ GetPolicyForApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PMP_009", - "message": "For given partner and apikey mapping not exists." + "errorCode": "PMS_PMP_009" } ] }' @@ -43,8 +42,7 @@ GetPolicyForApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PMP_009", - "message": "For given partner and apikey mapping not exists." + "errorCode": "PMS_PMP_009" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/GetPolicyforMappedPartnerAndCredentialtype.yml b/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/GetPolicyforMappedPartnerAndCredentialtype.yml index 427a46a92a6..9060a88ff88 100644 --- a/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/GetPolicyforMappedPartnerAndCredentialtype.yml +++ b/automationtests/src/main/resources/partner/GetPolicyforMappedPartnerAndCredentialtype/GetPolicyforMappedPartnerAndCredentialtype.yml @@ -27,8 +27,7 @@ GetPolicyforMappedPartnerAndCredentialtype: output: '{ "errors": [ { - "errorCode": "PMS_PRT_064", - "message": "No details found" + "errorCode": "PMS_PRT_064" } ] }' @@ -45,8 +44,7 @@ GetPolicyforMappedPartnerAndCredentialtype: output: '{ "errors": [ { - "errorCode": "PMS_PRT_064", - "message": "No details found" + "errorCode": "PMS_PRT_064" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml b/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml index 7a18d4c7aaa..8c3001857c1 100644 --- a/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml +++ b/automationtests/src/main/resources/partner/GetValueForConfigKey/GetValueForConfigKey.yml @@ -2,6 +2,7 @@ GetValueForConfigKey: partner_GetValueForConfigKey_allValid_smoke: endPoint: /v1/policymanager/policies/config/{key} role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetValueForConfigKey/getValueForConfigKey outputTemplate: partner/GetValueForConfigKey/getValueForConfigKeyResult @@ -16,6 +17,7 @@ GetValueForConfigKey: partner_GetValueForConfigKey_allValid_smoke: endPoint: /v1/policymanager/policies/config/{key} role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetValueForConfigKey/getValueForConfigKey outputTemplate: partner/GetValueForConfigKey/getValueForConfigKeyResult diff --git a/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs b/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs index bf0fa3d7dc0..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs +++ b/automationtests/src/main/resources/partner/GetValueForConfigKey/getValueForConfigKeyResult.hbs @@ -1,6 +1,2 @@ { - "response": { - "key": "{{key}}", - "value": "{{value}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml index 11aacbb2fbe..0277e5289a6 100644 --- a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml +++ b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml @@ -2,6 +2,7 @@ MapPartnerAndPolicytoCredentialType: Partner_MapPartnerAndPolicytoCredentialType_AllValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/credentialtype/{credentialType}/policies/{policyId} role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialType outputTemplate: partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult @@ -11,7 +12,6 @@ MapPartnerAndPolicytoCredentialType: "policyId": "mosip policy" }' output: '{ - "response": "Partner, policy and credentialType mapping done successfully." }' Partner_MapPartnerAndPolicytoCredentialType_InValid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/credentialtype/{credentialType}/policies/{policyId} @@ -27,8 +27,7 @@ MapPartnerAndPolicytoCredentialType: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' @@ -46,7 +45,7 @@ MapPartnerAndPolicytoCredentialType: output: '{ "errors": [ { - "errorCode": "PMS_PRT_098", + "errorCode": "PMS_PRT_098" } ] }' @@ -64,7 +63,7 @@ MapPartnerAndPolicytoCredentialType: output: '{ "errors": [ { - "errorCode": "PMS_PRT_072", + "errorCode": "PMS_PRT_072" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs +++ b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialTypeResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml index d708e9b4dbc..c4f30dc7c13 100644 --- a/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/CreateMispLicense/CreateMispLicense.yml @@ -40,8 +40,7 @@ CreateMispLicense: output: '{ "errors": [ { - "errorCode": "PMS_MSP_005", - "message": "MISP Partner does not exist" + "errorCode": "PMS_MSP_005" } ] }' diff --git a/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml index a7921dd24f3..5314834e538 100644 --- a/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/FilterMispLicense/FilterMispLicense.yml @@ -70,8 +70,7 @@ FilterMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-324", - "message": "Received Filter Type not supported" + "errorCode": "PMS-MSD-324" } ] }' @@ -92,8 +91,7 @@ FilterMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-322", - "message": "Filter Type cannot be empty or null" + "errorCode": "PMS-MSD-322" } ] }' @@ -135,8 +133,7 @@ FilterMispLicense: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - must not be blank :request.filters[0].columnName" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/GetMISPLicenseByMispID.yml b/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/GetMISPLicenseByMispID.yml index d559808e936..1359d77b93c 100644 --- a/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/GetMISPLicenseByMispID.yml +++ b/automationtests/src/main/resources/partner/MispLicense/GetMISPLicenseByMispID/GetMISPLicenseByMispID.yml @@ -11,8 +11,7 @@ GetMISPLicenseByMispID: output: '{ "errors": [ { - "errorCode": "PMS_MSP_413", - "message": "misp license all are inactive." + "errorCode": "PMS_MSP_413" } ] }' @@ -40,8 +39,7 @@ GetMISPLicenseByMispID: output: '{ "errors": [ { - "errorCode": "PMS_MSP_005", - "message": "MISP Partner does not exist" + "errorCode": "PMS_MSP_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml index 4d076d717c4..b81b7f8de49 100644 --- a/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml @@ -65,8 +65,7 @@ SearchMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-313", - "message": "Invalid pagination value received pagestart:0 and pagefetch:-1" + "errorCode": "PMS-MSD-313" } ] }' @@ -93,8 +92,7 @@ SearchMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-313", - "message": "Invalid pagination value received pagestart:-1 and pagefetch:1" + "errorCode": "PMS-MSD-313" } ] }' @@ -121,8 +119,7 @@ SearchMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type asdf is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -149,8 +146,7 @@ SearchMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field createddDateTime" + "errorCode": "PMS-MSD-357" } ] }' @@ -178,8 +174,7 @@ SearchMispLicense: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/UpdateMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/UpdateMispLicense.yml index e46a6ad5861..f02e6c86324 100644 --- a/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/UpdateMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/UpdateMispLicense/UpdateMispLicense.yml @@ -43,8 +43,7 @@ UpdateMispLicense: output: '{ "errors": [ { - "errorCode": "PMS_MSP_407", - "message": "mispStatus either Active or De-active." + "errorCode": "PMS_MSP_407" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml index 174f91e5687..1fbd9372135 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml +++ b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml @@ -2,6 +2,7 @@ createSearchPartner: Partner_SearchPartner_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult @@ -26,15 +27,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": true - } - ] }' Partner_SearchPartner_type__Smoke_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult @@ -59,15 +56,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": true - } - ] }' Partner_SearchPartner_type_contains_Smoke_desc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult @@ -92,11 +85,6 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": true - } - ] }' Partner_SearchPartner_type_equals_Smoke_desc_sid: endPoint: /v1/partnermanager/partners/search @@ -233,6 +221,7 @@ createSearchPartner: Partner_SearchPartner_columnname_id_desc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult @@ -257,15 +246,12 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": true - } - ] + }' Partner_SearchPartner_columnname_id_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult @@ -290,11 +276,6 @@ createSearchPartner: "version": "v1" }' output: '{ - "data": [ - { - "isActive": true - } - ] }' Partner_SearchPartner_columnname_address_asc_sid: endPoint: /v1/partnermanager/partners/search @@ -328,6 +309,7 @@ createSearchPartner: Partner_SearchPartner_columnname_address_desc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult @@ -383,8 +365,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-355", - "message": "No model found for the @22333sssdddfghmnjkiouyttrsx76 Receivedd" + "errorCode": "PMS-MSD-355" } ] }' @@ -417,8 +398,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-355", - "message": "No model found for the @22333sssdddfghmnjkiouyttrsx76 Receivedd" + "errorCode": "PMS-MSD-355" } ] }' @@ -451,8 +431,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-355", - "message": "No model found for the @22333sssdddfghmnjkiouyttrsx76 Receivedd" + "errorCode": "PMS-MSD-355" } ] }' @@ -485,8 +464,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-310", - "message": "Invalid column received:a@@@334455667788s" + "errorCode": "PMS-MSD-310" } ] }' @@ -519,8 +497,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-311", - "message": "Column is missing in request" + "errorCode": "PMS-MSD-311" } ] }' @@ -553,8 +530,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -587,8 +563,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -621,8 +596,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' @@ -655,8 +629,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field mo@@@del" + "errorCode": "PMS-MSD-357" } ] }' @@ -689,8 +662,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetails.yml b/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetails.yml index 96711c49dae..2d41411599f 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetails.yml +++ b/automationtests/src/main/resources/partner/PrintPartner/GetPartnerDetails/GetPartnerDetails.yml @@ -2,6 +2,7 @@ GetPartnerDetails: Partner_GetPartnerDetails_allValid_smoke: endPoint: /v1/partnermanager/partners/v2 role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/PrintPartner/GetPartnerDetails/GetPartnerDetails outputTemplate: partner/PrintPartner/GetPartnerDetails/GetPartnerDetailsResult diff --git a/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml index abade460cc3..8da1920121e 100644 --- a/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/PrintPartner/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ UploadPartnerCert: Partner_UploadCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/PrintPartner/UploadCert/uploadCert outputTemplate: partner/PrintPartner/UploadCert/uploadCertResult diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceType.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceType.yml index af4e9205306..89fbcb999df 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceType.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceType/createSearchDeviceType.yml @@ -154,8 +154,7 @@ createSearchDeviceType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-311", - "message": "Column is missing in request" + "errorCode": "PMS-MSD-311" } ] }' @@ -188,8 +187,7 @@ createSearchDeviceType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -222,8 +220,7 @@ createSearchDeviceType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -256,8 +253,7 @@ createSearchDeviceType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' @@ -290,8 +286,7 @@ createSearchDeviceType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field mo@@@del" + "errorCode": "PMS-MSD-357" } ] }' @@ -324,8 +319,7 @@ createSearchDeviceType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml index 1c2ce6237d1..c1ec1b36229 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml @@ -415,8 +415,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-310", - "message": "Invalid column received : a@@@334455667788s" + "errorCode": "PMS-MSD-310" } ] }' @@ -449,8 +448,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-311", - "message": "Column is missing in request" + "errorCode": "PMS-MSD-311" } ] }' @@ -483,8 +481,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -517,8 +514,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -551,8 +547,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' @@ -585,8 +580,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field mo@@@del" + "errorCode": "PMS-MSD-357" } ] }' @@ -619,8 +613,7 @@ createSearchPartner: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml index 8d5d630587b..201aaade954 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml @@ -123,8 +123,7 @@ SearchPartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS-MSD-313", - "message": "Invalid pagination value received pagestart:0 and pagefetch:0" + "errorCode": "PMS-MSD-313" } ] }' @@ -156,8 +155,7 @@ SearchPartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field abcd" + "errorCode": "PMS-MSD-357" } ] }' @@ -189,8 +187,7 @@ SearchPartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type abcd is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -222,8 +219,7 @@ SearchPartnerApiKey: output: '{ "errors": [ { - "errorCode": "PMS-MSD-310", - "message": "Invalid column received : abcd" + "errorCode": "PMS-MSD-310" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml index 754df577004..8733412cea9 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml @@ -2,6 +2,7 @@ SearchPartnerApiRequestKey: Partner_SearchPartnerApiRequestKey_AllValid_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKey outputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult @@ -38,6 +39,7 @@ SearchPartnerApiRequestKey: Partner_SearchPartnerApiRequestKey_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKey outputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult @@ -58,6 +60,7 @@ SearchPartnerApiRequestKey: Partner_SearchPartnerApiRequestKey_Only_PaginationCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKey outputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult @@ -116,8 +119,7 @@ SearchPartnerApiRequestKey: output: '{ "errors": [ { - "errorCode": "PMS-MSD-313", - "message": "Invalid pagination value received pagestart:0 and pagefetch:0" + "errorCode": "PMS-MSD-313" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs index c3e73352876..748df938dc3 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs @@ -8,5 +8,6 @@ {{#unless @last}},{{/unless}} {{/each}} ] - } + }, + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml index ffa718641bb..bfde52b2140 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerType/createSearchPartnerType.yml @@ -285,7 +285,7 @@ createSearchPartnerType: role: partner restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerType/createSearchPartnerType - outputTemplate: partner/SearchAPIs/SearchPartnerType/createSearchPartnerTypeResult + outputTemplate: partner/error input: '{ "filters": [ { @@ -306,13 +306,18 @@ createSearchPartnerType: "version": "v1" }' output: '{ + "errors": [ + { + "errorCode": "PMS-MSD-314" + } + ] }' Partner_SearchPartnerType_with_invalid_value_startswith: endPoint: /v1/partnermanager/partners/partnertype/search role: partner restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerType/createSearchPartnerType - outputTemplate: partner/SearchAPIs/SearchPartnerType/createSearchPartnerTypeResult + outputTemplate: partner/error input: '{ "filters": [ { @@ -333,6 +338,11 @@ createSearchPartnerType: "version": "v1" }' output: '{ + "errors": [ + { + "errorCode": "PMS-MSD-314" + } + ] }' Partner_SearchPartnerType_with_invalid_columnName: endPoint: /v1/partnermanager/partners/partnertype/search @@ -362,8 +372,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-310", - "message": "Invalid column received : co@@@@@343455666###4$$%%de" + "errorCode": "PMS-MSD-310" } ] }' @@ -395,8 +404,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-311", - "message": "Column is missing in request" + "errorCode": "PMS-MSD-311" } ] }' @@ -428,8 +436,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -461,8 +468,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -494,8 +500,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' @@ -527,8 +532,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type mo@@@del is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -560,8 +564,7 @@ createSearchPartnerType: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml index 075b647992a..f92c3582045 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml @@ -2,6 +2,7 @@ createSearchPolicy: Partner_SearchPolicy_AllValid_Smoke: endPoint: /partnermanagement/v1/policies/policy/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/Search/SearchPolicy/createSearchPolicy outputTemplate: partner/Search/SearchPolicy/createSearchPolicyResult @@ -17,6 +18,7 @@ createSearchPolicy: Partner_SearchPolicy_Only_FilterCriteria_Smoke: endPoint: /partnermanagement/v1/policies/policy/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/Search/SearchPolicy/createSearchPolicy outputTemplate: partner/Search/SearchPolicy/createSearchPolicyResult @@ -46,6 +48,7 @@ createSearchPolicy: Partner_SearchPolicy_Only_SortaCriteria_Smoke: endPoint: /partnermanagement/v1/policies/policy/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/Search/SearchPolicy/createSearchPolicy outputTemplate: partner/Search/SearchPolicy/createSearchPolicyResult @@ -67,6 +70,7 @@ createSearchPolicy: Partner_SearchPolicy_Only_PaginationCriteria_Smoke: endPoint: /partnermanagement/v1/policies/policy/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/Search/SearchPolicy/createSearchPolicy outputTemplate: partner/Search/SearchPolicy/createSearchPolicyResult @@ -348,6 +352,7 @@ createSearchPolicy: Partner_SearchPolicy_with_invalid_value_startswith: endPoint: /partnermanagement/v1/policies/policy/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/Search/SearchPolicy/createSearchPolicy outputTemplate: partner/Search/SearchPolicy/createSearchPolicyResult @@ -402,8 +407,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "KER-MSD-310", - "message": "Invalid column received:n@@@@@343e" + "errorCode": "KER-MSD-310" } ] }' @@ -464,8 +468,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -498,8 +501,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -532,8 +534,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' @@ -566,8 +567,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field n@@@@3334$$$e" + "errorCode": "PMS-MSD-357" } ] }' @@ -600,8 +600,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml index 9b5c591008b..43761fc344f 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml @@ -75,6 +75,7 @@ createSearchPolicyGroup: Partner_SearchPolicyGroup_type_contains_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -126,11 +127,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": true }' Partner_SearchPolicyGroup_type_equals_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -154,11 +155,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": true }' Partner_SearchPolicyGroup_type_equals_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -187,6 +188,7 @@ createSearchPolicyGroup: Partner_SearchPolicyGroup_type_startswith_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -210,11 +212,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": true }' Partner_SearchPolicyGroup_type_startswith_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -238,11 +240,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": true }' Partner_SearchPolicyGroup_columnname_id_desc_smoke: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -266,11 +268,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": true }' Partner_SearchPolicyGroup_columnname_id_asc_smoke: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -294,7 +296,6 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": true }' Partner_SearchPolicyGroup_with_missing_columnName: @@ -325,8 +326,7 @@ createSearchPolicyGroup: output: '{ "errors": [ { - "errorCode": "PMS-MSD-311", - "message": "Column is missing in request" + "errorCode": "PMS-MSD-311" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs index 0d69ee0dc7a..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs @@ -1,12 +1,2 @@ { - "response": { - "data": [ - {{#each data}} - { - "isActive": {{isActive}} - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDevice.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDevice.yml index d5ee877b409..ad1e917eb02 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDevice.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchRegisteredDevice/createSearchRegisteredDevice.yml @@ -319,8 +319,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "KER-MSD-355", - "message": "No model found for the b692b@@@3344##$$$f Receivedd" + "errorCode": "KER-MSD-355" } ] }' @@ -353,8 +352,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "KER-MSD-355", - "message": "No model found for the b692b@@@3344##$$$f Receivedd" + "errorCode": "KER-MSD-355" } ] }' @@ -387,8 +385,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "KER-MSD-355", - "message": "No model found for the b692b@@@3344##$$$f Receivedd" + "errorCode": "KER-MSD-355" } ] }' @@ -421,8 +418,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "KER-MSD-310", - "message": "Invalid column received:D@@@@##3334FFFGare" + "errorCode": "KER-MSD-310" } ] }' @@ -455,8 +451,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS-MSD-311", - "message": "Column is missing in request" + "errorCode": "PMS-MSD-311" } ] }' @@ -489,8 +484,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -523,8 +517,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -557,8 +550,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -591,8 +583,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field c@@@#333DDSSD" + "errorCode": "PMS-MSD-357" } ] }' @@ -625,8 +616,7 @@ createSearchRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml index 98670f41b2f..99838b046cb 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml @@ -2,6 +2,7 @@ createSearchSecureBiometric: Partner_SearchSecureBiometric_AllValid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric outputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult @@ -40,6 +41,7 @@ createSearchSecureBiometric: Partner_SearchSecureBiometric_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric outputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult @@ -59,6 +61,7 @@ createSearchSecureBiometric: Partner_SearchSecureBiometric_Only_PaginationCriteria_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric outputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult diff --git a/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/UpdatePolicyAgainstApiKey.yml b/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/UpdatePolicyAgainstApiKey.yml index c8cbd02097b..3b5344a65e3 100644 --- a/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/UpdatePolicyAgainstApiKey.yml +++ b/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/UpdatePolicyAgainstApiKey.yml @@ -2,6 +2,7 @@ UpdatePolicyAgainstApiKey: Partner_UpdatePolicyAgainstApiKey_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/apikey/{apiKey}/policies role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKey outputTemplate: partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult @@ -13,7 +14,6 @@ UpdatePolicyAgainstApiKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "message": "Given apikey updated with policy successfully. " }' Partner_UpdatePolicyAgainstApiKey_invalid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/apikey/{apiKey}/policies @@ -31,8 +31,7 @@ UpdatePolicyAgainstApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PMP_50", - "message": "Given apikey,partner and policy mapping not exists." + "errorCode": "PMS_PMP_50" } ] }' @@ -52,8 +51,7 @@ UpdatePolicyAgainstApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PMP_50", - "message": "Given apikey,partner and policy mapping not exists." + "errorCode": "PMS_PMP_50" } ] }' @@ -73,8 +71,7 @@ UpdatePolicyAgainstApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PMP_50", - "message": "Given apikey,partner and policy mapping not exists." + "errorCode": "PMS_PMP_50" } ] }' @@ -94,8 +91,7 @@ UpdatePolicyAgainstApiKey: output: '{ "errors": [ { - "errorCode": "PMS_PMP_014", - "message": "Policy does not existINVALID" + "errorCode": "PMS_PMP_014" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs b/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs index ba212b70ab8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs +++ b/automationtests/src/main/resources/partner/UpdatePolicyAgainstApiKey/updatePolicyAgainstApiKeyResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/UpdatePolicyGroupForPartner.yml b/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/UpdatePolicyGroupForPartner.yml index 521699e1a1f..1902baba51e 100644 --- a/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/UpdatePolicyGroupForPartner.yml +++ b/automationtests/src/main/resources/partner/UpdatePolicyGroupForPartner/UpdatePolicyGroupForPartner.yml @@ -2,6 +2,7 @@ UpdatePolicyGroupForPartner: Partner_UpdatePolicyGroupForPartner_AllValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/policygroup/{policygroupName} role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/UpdatePolicyGroupForPartner/updatePolicyGroupForPartner outputTemplate: partner/UpdatePolicyGroupForPartner/updatePolicyGroupForPartnerResult @@ -10,7 +11,7 @@ UpdatePolicyGroupForPartner: "policygroupName": "update_policy_group" }' output: '{ - "response": "Success" + "response": "$IGNORE$" }' Partner_UpdatePolicyGroupForPartner_InValid_ApprovedPartner: endPoint: /v1/partnermanager/partners/{partnerId}/policygroup/{policygroupName} @@ -25,8 +26,7 @@ UpdatePolicyGroupForPartner: output: '{ "errors": [ { - "errorCode": "PMS_PRT_050", - "message": "Policy group cannot be updated for approved partner" + "errorCode": "PMS_PRT_050" } ] }' @@ -43,8 +43,7 @@ UpdatePolicyGroupForPartner: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' @@ -61,8 +60,7 @@ UpdatePolicyGroupForPartner: output: '{ "errors": [ { - "errorCode": "PMS_PRT_002", - "message": "Policy group does not exist" + "errorCode": "PMS_PRT_002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml b/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml index 310ace3dcea..879f459c5e3 100644 --- a/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml +++ b/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml @@ -12,7 +12,6 @@ requetAPIKey: }' output: ' { "apiRequestId": "254785", - "message": "PartnerAPIKeyRequest successfully submitted and approved.", "apikeyId": "254785" }' @@ -30,8 +29,7 @@ requetAPIKey: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs b/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs index 08de5cbd505..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/AddContacts/AddContact.yml b/automationtests/src/main/resources/partner/authPartner/AddContacts/AddContact.yml index 499d831d5b1..7e266d37218 100644 --- a/automationtests/src/main/resources/partner/authPartner/AddContacts/AddContact.yml +++ b/automationtests/src/main/resources/partner/authPartner/AddContacts/AddContact.yml @@ -2,6 +2,7 @@ addContact: Partner_AddContact_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/Tech-123/contact/add role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/authPartner/AddContacts/addContact outputTemplate: partner/authPartner/AddContacts/addContactResult @@ -13,7 +14,6 @@ addContact: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Contacts details added successfully." }' Partner_AddContact_Missing_InputParameter_address: endPoint: /v1/partnermanager/partners/Tech-123/contact/add @@ -53,8 +53,7 @@ addContact: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.contactNumber" + "errorCode": "PMS_COR_001" } ] }' @@ -74,8 +73,7 @@ addContact: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.emailId" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs b/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/AddContacts/addContactResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/ApproveAPIKey.yml b/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/ApproveAPIKey.yml index 6d493e0119a..b39d0906dc1 100644 --- a/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/ApproveAPIKey.yml +++ b/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/ApproveAPIKey.yml @@ -2,6 +2,7 @@ ApproveAPIKey: Partner_ApproveRejectPartnerAPIKeyReq_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/policy/{mappingkey} role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/authPartner/ApproveAPIKey/approveAPIKey outputTemplate: partner/authPartner/ApproveAPIKey/approveAPIKeyResult @@ -11,7 +12,6 @@ ApproveAPIKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Policy mapping approved successfully" }' Partner_ApproveRejectPartnerAPIKeyReq_Missing_InputParameter_status: @@ -28,8 +28,7 @@ ApproveAPIKey: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.status" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml b/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml index f57769b004d..c463a361bbd 100644 --- a/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml +++ b/automationtests/src/main/resources/partner/authPartner/CreatePartner/CreatePartner.yml @@ -38,8 +38,7 @@ createPartnerSelfRegistration: output: ' { "errors": [ { - "errorCode": "PMS_PRT_051", - "message": "A Partner is already registered with the same Id" + "errorCode": "PMS_PRT_051" } ] }' @@ -82,8 +81,7 @@ createPartnerSelfRegistration: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.partnerId" + "errorCode": "PMS_COR_001" } ] }' @@ -133,8 +131,7 @@ createPartnerSelfRegistration: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.contactNumber" + "errorCode": "PMS_COR_001" } ] }' @@ -182,8 +179,7 @@ createPartnerSelfRegistration: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.partnerType" + "errorCode": "PMS_COR_001" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml index f2b414f3ef5..a29a08941da 100644 --- a/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml @@ -23,8 +23,7 @@ GetPartnerCert: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' @@ -40,8 +39,7 @@ GetPartnerCert: output: '{ "errors": [ { - "errorCode": "PMS_PRT_108", - "message": "Certficate is not uploaded for the selected partner." + "errorCode": "PMS_PRT_108" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/GetPartner/GetPartner.yml b/automationtests/src/main/resources/partner/authPartner/GetPartner/GetPartner.yml index 8f6b9bf851e..4afb9825a95 100644 --- a/automationtests/src/main/resources/partner/authPartner/GetPartner/GetPartner.yml +++ b/automationtests/src/main/resources/partner/authPartner/GetPartner/GetPartner.yml @@ -11,8 +11,7 @@ GetPartnerDetails: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/RejectAPIKey.yml b/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/RejectAPIKey.yml index ef703dac60d..5067e83b86c 100644 --- a/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/RejectAPIKey.yml +++ b/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/RejectAPIKey.yml @@ -2,6 +2,7 @@ RejectAPIKey: Partner_ApproveRejectPartnerAPIKeyReq_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/policy/{mappingkey} role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/authPartner/RejectAPIKey/rejectAPIKey outputTemplate: partner/authPartner/RejectAPIKey/rejectAPIKeyResult @@ -11,7 +12,6 @@ RejectAPIKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Policy mapping rejected successfully" }' Partner_ApproveRejectPartnerAPIKeyReq_Missing_InputParameter_status: @@ -28,8 +28,7 @@ RejectAPIKey: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.status" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs b/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/RejectAPIKey/rejectAPIKeyResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml index 30968b1f1bf..b1ed3f2c842 100644 --- a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml +++ b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml @@ -2,6 +2,7 @@ RequestAPIKeyForAuthPartner: Partner_SubmitPartnerApiKeyRequest_Rejection_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/partners/Tech-123/policy/map role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/authPartner/RequestAPIKey/requestApiKey outputTemplate: partner/authPartner/RequestAPIKey/requestAPIKeyResult @@ -11,11 +12,11 @@ RequestAPIKeyForAuthPartner: "requesttime": "$TIMESTAMP$" }' output: '{ - "message": "Policy mapping request submitted successfully." }' Partner_SubmitPartnerApiKeyRequest_Approval_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/partners/Tech-123/policy/map role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/authPartner/RequestAPIKey/requestApiKey outputTemplate: partner/authPartner/RequestAPIKey/requestAPIKeyResult @@ -25,7 +26,6 @@ RequestAPIKeyForAuthPartner: "requesttime": "$TIMESTAMP$" }' output: '{ - "message": "Policy mapping request submitted successfully." }' Partner_SubmitPartnerApiKeyRequest_invalid_policyName: endPoint: /v1/partnermanager/partners/Tech-123/policy/map @@ -59,8 +59,7 @@ RequestAPIKeyForAuthPartner: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs index abcbd48dff4..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/requestAPIKeyResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/UpdatePartner/UpdatePartner.yml b/automationtests/src/main/resources/partner/authPartner/UpdatePartner/UpdatePartner.yml index 33993ae2b85..6328462b467 100644 --- a/automationtests/src/main/resources/partner/authPartner/UpdatePartner/UpdatePartner.yml +++ b/automationtests/src/main/resources/partner/authPartner/UpdatePartner/UpdatePartner.yml @@ -29,8 +29,7 @@ updatePartnerDetails: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' @@ -49,8 +48,7 @@ updatePartnerDetails: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.address" + "errorCode": "PMS_COR_001" } ] }' @@ -69,8 +67,7 @@ updatePartnerDetails: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.contactNumber" + "errorCode": "PMS_COR_001" } ] }' diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml index 63e0d635254..c3715fd9d7f 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml +++ b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml @@ -2,6 +2,7 @@ uploadCACert: Partner_UploadCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/authPartner/UploadCertificate/uploadCertificate outputTemplate: partner/authPartner/UploadCertificate/uploadCertificateResult @@ -9,7 +10,6 @@ uploadCACert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' Partner_UploadCACertificate_UploadAgain_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs index 8b1342210ff..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "status": "{{status}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml b/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml index 325b582dc2e..5a0857c3487 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/APIKeyAutoApproval.yml @@ -12,6 +12,5 @@ requetAPIKey: }' output: ' { "apiRequestId": "254785", - "message": "PartnerAPIKeyRequest successfully submitted and approved.", "apikeyId": "254785" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs index 08de5cbd505..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/APIKeyAutoApproval/apiKeyAutoApprovalResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/AddBioExtractors.yml b/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/AddBioExtractors.yml index 43105c67710..54577c76461 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/AddBioExtractors.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/AddBioExtractors.yml @@ -2,6 +2,7 @@ addBioExtractors: Partner_AddBioExtractors_MosipDataSharePolicy_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/{partnerId}/bioextractors/{policyId} role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/AddBioExtractors/addBioExtractors outputTemplate: partner/credentialPartner/AddBioExtractors/addBioExtractorsResult @@ -10,11 +11,11 @@ addBioExtractors: "policyId":"MDSP", "requesttime": "$TIMESTAMP$" }' - output: '{"message":"Extractors added successfully."}' Partner_AddBioExtractors_MosipPolicy_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/{partnerId}/bioextractors/{policyId} role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/AddBioExtractors/addBioExtractors outputTemplate: partner/credentialPartner/AddBioExtractors/addBioExtractorsResult @@ -23,7 +24,6 @@ addBioExtractors: "policyId":"$ID:DefinePolicy_All_Valid_Smoke_sid_id$", "requesttime": "$TIMESTAMP$" }' - output: '{"message":"Extractors added successfully."}' Partner_AddBioExtractors_invalid_policyId: endPoint: /v1/partnermanager/partners/{partnerId}/bioextractors/{policyId} @@ -39,8 +39,7 @@ addBioExtractors: output: '{ "errors": [ { - "errorCode": "PMS_PRT_061", - "message": "Partner policy mapping not exists." + "errorCode": "PMS_PRT_061" } ] }' @@ -59,8 +58,7 @@ addBioExtractors: output: '{ "errors": [ { - "errorCode": "PMS_PRT_061", - "message": "Partner policy mapping not exists." + "errorCode": "PMS_PRT_061" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs index 9f8a4a538a5..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/AddBioExtractors/addBioExtractorsResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{message}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/ApproveAPIKey.yml b/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/ApproveAPIKey.yml index 72bf5b55aa4..3c7f8e6e356 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/ApproveAPIKey.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/ApproveAPIKey.yml @@ -2,6 +2,7 @@ ApproveAPIKey: Partner_ApproveRejectPartnerAPIKeyReq_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/policy/{mappingkey} role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/credentialPartner/ApproveAPIKey/approveAPIKey outputTemplate: partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult @@ -28,8 +29,7 @@ ApproveAPIKey: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.status" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/ApproveAPIKey/approveAPIKeyResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/GetPartner/GetPartner.yml b/automationtests/src/main/resources/partner/credentialPartner/GetPartner/GetPartner.yml index 85194f908ca..f16f4aad251 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/GetPartner/GetPartner.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/GetPartner/GetPartner.yml @@ -25,8 +25,7 @@ getPartnerCert: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' diff --git a/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/RejectAPIKey.yml b/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/RejectAPIKey.yml index 2405ce4e176..6dc155c88fb 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/RejectAPIKey.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/RejectAPIKey.yml @@ -2,6 +2,7 @@ RejectAPIKey: Partner_ApproveRejectPartnerAPIKeyReq_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/policy/{mappingkey} role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/credentialPartner/RejectAPIKey/rejectAPIKey outputTemplate: partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult @@ -11,7 +12,6 @@ RejectAPIKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Policy mapping rejected successfully" }' Partner_ApproveRejectPartnerAPIKeyReq_Missing_InputParameter_status: @@ -28,8 +28,7 @@ RejectAPIKey: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.status" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/RejectAPIKey/rejectAPIKeyResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml index 42d6c2cc59a..d79329be38c 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/RequestAPIKey.yml @@ -2,6 +2,7 @@ RequestAPIKeyCredentialPartner: Partner_CredPartnerApiKeyRequest_Approval_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/partners/MOVP/policy/map role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/RequestAPIKey/requestApiKey outputTemplate: partner/credentialPartner/RequestAPIKey/requestAPIKeyResult @@ -11,11 +12,11 @@ RequestAPIKeyCredentialPartner: "requesttime": "$TIMESTAMP$" }' output: ' { - "message": "Policy mapping request submitted successfully." }' Partner_CredPartnerApiKeyRequest_Rejection_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/partners/MOVP/policy/map role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/RequestAPIKey/requestApiKey outputTemplate: partner/credentialPartner/RequestAPIKey/requestAPIKeyResult @@ -25,5 +26,4 @@ RequestAPIKeyCredentialPartner: "requesttime": "$TIMESTAMP$" }' output: ' { - "message": "Policy mapping request submitted successfully." }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs index 1969a7e3c0e..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/RequestAPIKey/requestAPIKeyResult.hbs @@ -1,4 +1,2 @@ { - "message": "{{message}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs index 51a54105dc5..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/UploadCert/uploadCertResult.hbs @@ -1,4 +1,2 @@ { - "response": { - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/UploadCertificate.yml b/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/UploadCertificate.yml index d2055db16c3..b2f9c8e762d 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/UploadCertificate.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/UploadCertificate.yml @@ -2,6 +2,7 @@ uploadCert: Partner_UploadCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/UploadCertificate/uploadCertificate outputTemplate: partner/credentialPartner/UploadCertificate/uploadCertificateResult @@ -9,11 +10,11 @@ uploadCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' Partner_UploadSUBCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/UploadCertificate/uploadSUBCACertificate outputTemplate: partner/credentialPartner/UploadCertificate/uploadCertificateResult @@ -21,5 +22,4 @@ uploadCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' diff --git a/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs index 8b1342210ff..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/credentialPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "status": "{{status}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml index dd4e8b3acb6..f01d8fb7dba 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml @@ -2,6 +2,7 @@ MapDeviceWithSBI: Partner_MapDeviceWithSBI_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/securebiometricinterface/devicedetails/map role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBI outputTemplate: partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult @@ -10,11 +11,11 @@ MapDeviceWithSBI: "sbiId": "$ID:SaveSecureBiometricInterface_All_Valid_Smoke_sid_id$" }' output: '{ - "response": "Success" }' Partner_MapDeviceWithSBI_Multiple_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/securebiometricinterface/devicedetails/map role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBI outputTemplate: partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult @@ -23,5 +24,4 @@ MapDeviceWithSBI: "sbiId": "$ID:SaveSecureBiometricInterface_Valid_Smoke_sid_id$" }' output: '{ - "response": "Success" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBIResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/ApproveSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/ApproveSecureBiometricInterface.yml index dffe23a57b5..badcf1bceeb 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/ApproveSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/ApproveSecureBiometricInterface.yml @@ -2,6 +2,7 @@ ApproveSecureBiometricInterface: Partner_ApproveSecureBiometricInterface_All_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterface outputTemplate: partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult @@ -12,7 +13,7 @@ ApproveSecureBiometricInterface: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Secure biometric details approved successfully." + "response": "$IGNORE" }' Partner_ApproveSecureBiometricInterface_Missing_InputParameter_approvalStatus: @@ -30,8 +31,7 @@ ApproveSecureBiometricInterface: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.approvalStatus" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/approve/approveSecureBiometricInterfaceResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml index e66d67be424..4fabe21ee29 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml @@ -2,6 +2,7 @@ createSaveSecureBiometricInterface: Partner_SaveSecureBiometricInterface_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/securebiometricinterface role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/SecureBiometricInterface/create/createSecureBiometricInterface outputTemplate: partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult @@ -18,6 +19,7 @@ createSaveSecureBiometricInterface: Partner_SaveSecureBiometricInterface_Valid_Smoke_sid: endPoint: /v1/partnermanager/securebiometricinterface role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/SecureBiometricInterface/create/createSecureBiometricInterface outputTemplate: partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult @@ -48,8 +50,7 @@ createSaveSecureBiometricInterface: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.swVersion" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml index 62cb3c03396..39636c2c2f5 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml @@ -2,6 +2,7 @@ RejectSecureBiometricInterface: Partner_RejectSecureBiometricInterface_All_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterface outputTemplate: partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult @@ -12,11 +13,11 @@ RejectSecureBiometricInterface: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Secure biometric details rejected successfully." }' Partner_RejectSecureBiometricInterface_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterface outputTemplate: partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult @@ -27,7 +28,6 @@ RejectSecureBiometricInterface: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Secure biometric details rejected successfully." }' Partner_RejectSecureBiometricInterface_Missing_InputParameter_approvalStatus: endPoint: /v1/partnermanager/securebiometricinterface @@ -44,8 +44,7 @@ RejectSecureBiometricInterface: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.approvalStatus" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterfaceResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/update/UpdateSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/update/UpdateSecureBiometricInterface.yml index ce6e197a289..58145f023a9 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/update/UpdateSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/update/UpdateSecureBiometricInterface.yml @@ -2,6 +2,7 @@ createUpdateSecureBiometricInterface: Partner_UpdateSecureBiometricInterface_All_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/device/SecureBiometricInterface/update/updateSecureBiometricInterface outputTemplate: partner/device/SecureBiometricInterface/update/updateSecureBiometricInterfaceResult @@ -17,7 +18,6 @@ createUpdateSecureBiometricInterface: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$ID:SaveSecureBiometricInterface_All_Valid_Smoke_sid_id$" }' Partner_UpdateSecureBiometricInterface_AfterReject_All_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface @@ -59,8 +59,7 @@ createUpdateSecureBiometricInterface: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.id" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/deregistration/DeRegisterDevice.yml b/automationtests/src/main/resources/partner/device/deregistration/DeRegisterDevice.yml index acaef3d2e9a..233d9adb2d9 100644 --- a/automationtests/src/main/resources/partner/device/deregistration/DeRegisterDevice.yml +++ b/automationtests/src/main/resources/partner/device/deregistration/DeRegisterDevice.yml @@ -2,6 +2,7 @@ createDeRegisterDevice: Partner_DeRegisterDevice_All_Valid_Smoke: endPoint: /v1/partnermanager/registereddevices/deregister role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/deregistration/deRegisterDevice outputTemplate: partner/device/deregistration/deRegisterDeviceResult @@ -11,6 +12,5 @@ createDeRegisterDevice: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "Device details approved successfully." }' diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/ApproveFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/ApproveFtpChipDetail.yml index f69727c9518..13479c6eec2 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/ApproveFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/ApproveFtpChipDetail.yml @@ -2,6 +2,7 @@ ApproveFtpChipDetail: Partner_ApproveFtpChipDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/ftpchipdetail role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/ftmChipDetails/approve/approveFtpChipDetail outputTemplate: partner/device/ftmChipDetails/approve/approveFtpChipDetailResult @@ -11,7 +12,6 @@ ApproveFtpChipDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "Status updated successfully." }' Partner_ApproveFtpChipDetail_Missing_InputParameter_ftpChipDetailId: @@ -29,8 +29,7 @@ ApproveFtpChipDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.ftpChipDetailId" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs index b8eed36f548..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/approve/approveFtpChipDetailResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "id": "{{id}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml index 56600b6ec66..c028d58bf0f 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml @@ -13,6 +13,7 @@ CreateFTPChipDetail: "requesttime": "$TIMESTAMP$" }' output: '{ + "id": "$IGNORE$" }' Partner_CreateFTPChipDetail_Missing_InputParameter_ftpProviderId: @@ -30,8 +31,7 @@ CreateFTPChipDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.make" + "errorCode": "PMS_COR_001" } ] }' @@ -51,8 +51,7 @@ CreateFTPChipDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.ftpProviderId" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml index 0802e14ae24..391261a6663 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/get/GetFtpChipDetail.yml @@ -2,6 +2,7 @@ GetFTPChipDetail: Partner_GetFtpChipDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/ftpchipdetail/getPartnerCertificate/{ftpChipDetailId} role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/ftmChipDetails/get/getFtpChipDetail outputTemplate: partner/device/ftmChipDetails/get/getFtpChipDetailResult diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml index e258eb61cc4..e729512815c 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml @@ -28,8 +28,7 @@ rejectFtpChipDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.ftpChipDetailId" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs index e84accca3de..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml index a14c271a5af..482f8e1a7f2 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml @@ -30,8 +30,7 @@ UpdateFtpChipDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.ftpChipDetailId" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs index b8eed36f548..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/updateFtpChipDetailResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "id": "{{id}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml index f8518deaf5c..91b9fa2740e 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/uploadcert/Uploadcertificate.yml @@ -2,6 +2,7 @@ UploadCertificateOfFtpChip: Partner_UploadCertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/ftpchipdetail/uploadcertificate role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/ftmChipDetails/uploadcert/uploadcertificate outputTemplate: partner/device/ftmChipDetails/uploadcert/uploadcertificateResult @@ -30,8 +31,7 @@ UploadCertificateOfFtpChip: output: ' { "errors": [ { - "errorCode": "PMP_AUT_030", - "message": "ftp provider not exists." + "errorCode": "PMP_AUT_030" } ] }' @@ -51,8 +51,7 @@ UploadCertificateOfFtpChip: output: ' { "errors": [ { - "errorCode": "PMP_AUT_031", - "message": "ftp chip id not exists." + "errorCode": "PMP_AUT_031" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/approve/ApproveDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/approve/ApproveDeviceDetail.yml index be9802c59c8..f03ebc3e033 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/approve/ApproveDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/approve/ApproveDeviceDetail.yml @@ -2,6 +2,7 @@ createApproveRejectDeviceDetail: Partner_ApproveRejectDeviceDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/makeAndModel/approve/approveDeviceDetail outputTemplate: partner/device/makeAndModel/approve/approveDeviceDetailResult @@ -12,7 +13,6 @@ createApproveRejectDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Device details approved successfully." }' Partner_ApproveRejectDeviceDetail_Missing_InputParameter_approvalStatus: @@ -30,8 +30,7 @@ createApproveRejectDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.approvalStatus" + "errorCode": "PMS_COR_001" } ] }' @@ -52,8 +51,7 @@ createApproveRejectDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.id" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/approve/approveDeviceDetailResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml index acffac6a4c7..d95c5c1c8cd 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml @@ -42,6 +42,7 @@ createServiceToSaveDeviceDetail: Partner_ServiceToSaveDeviceDetail_sameMakeModel_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/makeAndModel/create/createDeviceDetail outputTemplate: partner/device/makeAndModel/create/createDeviceDetailResult @@ -61,6 +62,7 @@ createServiceToSaveDeviceDetail: Partner_ServiceToSaveDeviceDetail_sameTypeSubType_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/makeAndModel/create/createDeviceDetail outputTemplate: partner/device/makeAndModel/create/createDeviceDetailResult @@ -97,8 +99,7 @@ createServiceToSaveDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_AUT_003", - "message": "Device Details already exists" + "errorCode": "PMS_AUT_003" } ] }' @@ -122,8 +123,7 @@ createServiceToSaveDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_AUT_001", - "message": "Reg Device Sub Type Code not found in the list of Reg Device Sub Types" + "errorCode": "PMS_AUT_001" } ] }' @@ -200,8 +200,7 @@ createServiceToSaveDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.deviceTypeCode" + "errorCode": "PMS_COR_001" } ] }' diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/reject/RejectDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/reject/RejectDeviceDetail.yml index 7ed3766e5d0..77e968881ed 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/reject/RejectDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/reject/RejectDeviceDetail.yml @@ -2,6 +2,7 @@ rejectDeviceDetail: Partner_rejectDeviceDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/makeAndModel/approve/approveDeviceDetail outputTemplate: partner/device/makeAndModel/approve/approveDeviceDetailResult @@ -12,11 +13,11 @@ rejectDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Device details rejected successfully." }' Partner_rejectDeviceDetail_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/makeAndModel/approve/approveDeviceDetail outputTemplate: partner/device/makeAndModel/approve/approveDeviceDetailResult @@ -27,7 +28,6 @@ rejectDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "response": "Device details rejected successfully." }' Partner_rejectDeviceDetail_Missing_InputParameter_approvalStatus: endPoint: /v1/partnermanager/devicedetail @@ -44,8 +44,7 @@ rejectDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.approvalStatus" + "errorCode": "PMS_COR_001" } ] }' @@ -66,8 +65,7 @@ rejectDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.id" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs index eb8d6fea9a8..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/reject/rejectDeviceDetailResult.hbs @@ -1,3 +1,2 @@ { - "response": "{{response}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml index 1545d3847bc..6b5640bf2d2 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml @@ -64,8 +64,7 @@ createServiceToUpdateDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.id" + "errorCode": "PMS_COR_001" } ] }' @@ -93,8 +92,7 @@ createServiceToUpdateDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_AUT_001", - "message": "Reg Device Sub Type Code not found in the list of Reg Device Sub Types" + "errorCode": "PMS_AUT_001" } ] }' @@ -121,8 +119,7 @@ createServiceToUpdateDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.deviceSubTypeCode" + "errorCode": "PMS_COR_001" } ] }' @@ -148,8 +145,7 @@ createServiceToUpdateDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.deviceTypeCode" + "errorCode": "PMS_COR_001" } ] }' diff --git a/automationtests/src/main/resources/partner/device/registration/RegistereDevice.yml b/automationtests/src/main/resources/partner/device/registration/RegistereDevice.yml index a265a816bd1..fb52e49acff 100644 --- a/automationtests/src/main/resources/partner/device/registration/RegistereDevice.yml +++ b/automationtests/src/main/resources/partner/device/registration/RegistereDevice.yml @@ -2,6 +2,7 @@ createSignedRegisteredDevice: Partner_SignedRegisteredDevice_All_Valid_Smoke: endPoint: /v1/partnermanager/registereddevices role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/registration/registereDevice outputTemplate: partner/device/registration/registereDeviceResult @@ -11,7 +12,6 @@ createSignedRegisteredDevice: }' output: '{ - "id": "Device details approved successfully." }' Partner_SignedRegisteredDevice_Missing_InputParameter_deviceData: @@ -28,8 +28,7 @@ createSignedRegisteredDevice: output: '{ "errors": [ { - "errorCode": "PMS_AUT_015", - "message": "Serial no and Device detail already exist" + "errorCode": "PMS_AUT_015" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml index 1054917cda4..152fd51be55 100644 --- a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml @@ -23,8 +23,7 @@ GetPartnerCert: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/GetPartner/GetPartner.yml b/automationtests/src/main/resources/partner/devicePartner/GetPartner/GetPartner.yml index 2d016aa1a83..8c2f589f224 100644 --- a/automationtests/src/main/resources/partner/devicePartner/GetPartner/GetPartner.yml +++ b/automationtests/src/main/resources/partner/devicePartner/GetPartner/GetPartner.yml @@ -23,8 +23,7 @@ GetPartnerDetails: output: '{ "errors": [ { - "errorCode": "PMS_PRT_005", - "message": "Partner does not exist" + "errorCode": "PMS_PRT_005" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs b/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs index 51a54105dc5..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/UploadCert/uploadCertResult.hbs @@ -1,4 +1,2 @@ { - "response": { - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/UploadCertificate.yml b/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/UploadCertificate.yml index 212b5bd1b5a..476c1455816 100644 --- a/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/UploadCertificate.yml +++ b/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/UploadCertificate.yml @@ -2,6 +2,7 @@ uploadCert: Partner_UploadCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/devicePartner/UploadCertificate/uploadCertificate outputTemplate: partner/devicePartner/UploadCertificate/uploadCertificateResult @@ -9,11 +10,11 @@ uploadCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' Partner_UploadSUBCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/devicePartner/UploadCertificate/uploadSUBCACertificate outputTemplate: partner/devicePartner/UploadCertificate/uploadCertificateResult @@ -21,6 +22,5 @@ uploadCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' diff --git a/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs index 8b1342210ff..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/devicePartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "status": "{{status}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/UploadCertificate.yml b/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/UploadCertificate.yml index 0b8ca7acc30..0e4f91cb7e9 100644 --- a/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/UploadCertificate.yml +++ b/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/UploadCertificate.yml @@ -2,6 +2,7 @@ uploadCert: Partner_UploadCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/mispPartner/UploadCertificate/uploadCertificate outputTemplate: partner/mispPartner/UploadCertificate/uploadCertificateResult @@ -9,11 +10,11 @@ uploadCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' Partner_UploadSUBCACertificate_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/ca/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/mispPartner/UploadCertificate/uploadSUBCACertificate outputTemplate: partner/mispPartner/UploadCertificate/uploadCertificateResult @@ -21,6 +22,5 @@ uploadCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "status": "Upload Success." }' diff --git a/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs b/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs index 8b1342210ff..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs +++ b/automationtests/src/main/resources/partner/mispPartner/UploadCertificate/uploadCertificateResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "status": "{{status}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/DefineDataSharePolicy.yml b/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/DefineDataSharePolicy.yml index e7966f7827c..bca3bca89db 100644 --- a/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/DefineDataSharePolicy.yml +++ b/automationtests/src/main/resources/partner/policy/DefineDataSharePolicy/DefineDataSharePolicy.yml @@ -65,8 +65,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_009", - "message": "Auth policy exists with name : mosip data share policy" + "errorCode": "PMS_POL_009" } ] }' @@ -90,8 +89,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_053", - "message": "Policy group is not active." + "errorCode": "PMS_POL_053" } ] }' @@ -115,8 +113,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_019", - "message": "Policy group name does not exist" + "errorCode": "PMS_POL_019" } ] }' @@ -140,8 +137,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_023", - "message": "Given policy type is not allowed " + "errorCode": "PMS_POL_023" } ] }' @@ -165,8 +161,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.name" + "errorCode": "PMS_COR_001" } ] }' @@ -190,8 +185,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.desc" + "errorCode": "PMS_COR_001" } ] }' @@ -215,8 +209,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.policyGroupName" + "errorCode": "PMS_COR_001" } ] }' @@ -240,8 +233,7 @@ defineDataSharePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null. Allowed values Auth/DataShare/CredentialIssuance :request.policyType" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/DefinePolicy/DefinePolicy.yml b/automationtests/src/main/resources/partner/policy/DefinePolicy/DefinePolicy.yml index 5fb7244c506..d6cf3e13f5e 100644 --- a/automationtests/src/main/resources/partner/policy/DefinePolicy/DefinePolicy.yml +++ b/automationtests/src/main/resources/partner/policy/DefinePolicy/DefinePolicy.yml @@ -96,8 +96,7 @@ definePolicy: output: ' { "errors": [ { - "errorCode": "PMS_POL_009", - "message": "Auth policy exists with name : mosip policy" + "errorCode": "PMS_POL_009" } ] }' @@ -123,8 +122,7 @@ definePolicy: output: ' { "errors": [ { - "errorCode": "PMS_POL_019", - "message": "Policy group name does not exist" + "errorCode": "PMS_POL_019" } ] }' @@ -150,8 +148,7 @@ definePolicy: output: ' { "errors": [ { - "errorCode": "PMS_POL_053", - "message": "Policy group is not active." + "errorCode": "PMS_POL_053" } ] }' @@ -177,8 +174,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.name" + "errorCode": "PMS_COR_001" } ] }' @@ -204,8 +200,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.desc" + "errorCode": "PMS_COR_001" } ] }' @@ -231,8 +226,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_PV_006", - "message": "Missing input parameter - allowedAuthTypes/0/mandatory" + "errorCode": "PMS_PV_006" } ] }' @@ -258,8 +252,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_PV_006", - "message": "Missing input parameter - allowedAuthTypes/0/authType" + "errorCode": "PMS_PV_006" } ] }' @@ -285,8 +278,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_PV_006", - "message": "Missing input parameter - authTokenType" + "errorCode": "PMS_PV_006" } ] }' @@ -312,8 +304,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_PV_006", - "message": "Missing input parameter - allowedKycAttributes/0/attributeName" + "errorCode": "PMS_PV_006" } ] }' @@ -339,8 +330,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.policyGroupName" + "errorCode": "PMS_COR_001" } ] }' @@ -366,8 +356,7 @@ definePolicy: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null. Allowed values Auth/DataShare/CredentialIssuance :request.policyType" + "errorCode": "PMS_COR_001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs b/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs index d65415308da..101febb627e 100644 --- a/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/policy/DefinePolicyGroup/definePolicyGroupResult.hbs @@ -2,6 +2,6 @@ "response": { "name": "{{name}}", "desc": "{{desc}}", - "is_Active": {{is_Active}}, + "is_Active": {{is_Active}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs index 79c7c73cf29..6fa2126bf0d 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs @@ -4,6 +4,6 @@ "policyGroupDesc": "{{policyGroupDesc}}", "policyGroupStatus": {{policyGroupStatus}}, "policyName": "{{policyName}}", - "policyDesc": "{{policyDesc}}", + "policyDesc": "{{policyDesc}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/GetPolicyGroup/GetPolicyGroup.yml b/automationtests/src/main/resources/partner/policy/GetPolicyGroup/GetPolicyGroup.yml index 9e57b22198c..5174513cf30 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicyGroup/GetPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/policy/GetPolicyGroup/GetPolicyGroup.yml @@ -25,8 +25,7 @@ getPolicyGroup: output: '{ "errors": [ { - "errorCode": "PMS_POL_016", - "message": "Policy Group ID does not exist" + "errorCode": "PMS_POL_016" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/PublishDataSharePolicy.yml b/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/PublishDataSharePolicy.yml index b8481b82227..408fff76913 100644 --- a/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/PublishDataSharePolicy.yml +++ b/automationtests/src/main/resources/partner/policy/PublishDataSharePolicy/PublishDataSharePolicy.yml @@ -36,8 +36,7 @@ createPublishPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_020", - "message": "Can not publish the published policy" + "errorCode": "PMS_POL_020" } ] }' @@ -55,8 +54,7 @@ createPublishPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_016", - "message": "Policy Group ID does not exist" + "errorCode": "PMS_POL_016" } ] }' @@ -74,8 +72,7 @@ createPublishPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_008", - "message": "Policy ID does not exist" + "errorCode": "PMS_POL_008" } ] }' diff --git a/automationtests/src/main/resources/partner/policy/PublishPolicy/PublishPolicy.yml b/automationtests/src/main/resources/partner/policy/PublishPolicy/PublishPolicy.yml index 4f453f9e01a..da15493aed6 100644 --- a/automationtests/src/main/resources/partner/policy/PublishPolicy/PublishPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/PublishPolicy/PublishPolicy.yml @@ -39,8 +39,7 @@ createPublishPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_020", - "message": "Can not publish the published policy" + "errorCode": "PMS_POL_020" } ] }' @@ -58,8 +57,7 @@ createPublishPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_016", - "message": "Policy Group ID does not exist" + "errorCode": "PMS_POL_016" } ] }' @@ -77,8 +75,7 @@ createPublishPolicy: output: '{ "errors": [ { - "errorCode": "PMS_POL_008", - "message": "Policy ID does not exist" + "errorCode": "PMS_POL_008" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index ffe603ba382..cbab1a3466e 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -122,7 +122,8 @@ createSearchPolicy: "data": [ { "version": "1.0", - "policyType": "DataShare" + "policyType": "DataShare", + "schema": "$IGNORE$" } ] }' @@ -156,7 +157,8 @@ createSearchPolicy: "data": [ { "version": "1.0", - "policyType": "DataShare" + "policyType": "DataShare", + "schema": "$IGNORE$" } ] }' @@ -295,7 +297,8 @@ createSearchPolicy: "data": [ { "version": "1.0", - "policyType": "DataShare" + "policyType": "DataShare", + "schema": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs b/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs index 92ba38bc16c..23bf0f37163 100644 --- a/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/UpdatePolicy/updatePolicyResult.hbs @@ -3,6 +3,6 @@ "policyGroupName": "{{policyGroupName}}", "name": "{{name}}", "desc": "{{desc}}", - "is_Active": {{is_Active}}, + "is_Active": {{is_Active}} } } \ No newline at end of file From c9bcca41aa65a3fd08c4eeecadf5188f9caa3759 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 29 Aug 2023 10:24:31 +0530 Subject: [PATCH 089/204] MOSIP-29081 --- .../idRepository/AddIdentity/AddIdentity.yml | 55 +++----- .../AddIdentity/addIdentityResult.hbs | 8 +- .../AuthInternalLock/AuthInternalLock.yml | 74 +++++------ .../AuthInternalLockResult.hbs | 6 - .../AuthInternalUnlock/AuthInternalUnlock.yml | 72 +++++------ .../AuthInternalUnlockResult.hbs | 6 - .../idRepository/CreateDraft/CreateDraft.yml | 10 +- .../CreateDraft/createDraftResult.hbs | 11 -- .../CreateDraftVID/CreateDraftVID.yml | 12 +- .../CreateDraftVID/createDraftVIDResult.hbs | 9 +- .../idRepository/CreateVID/CreateVid.yml | 90 +++++-------- .../CreateVID/createVidResult.hbs | 12 +- .../DeactivateVid/DeactivateVid.yml | 57 +++------ .../DeactivateVid/deactivateVidResult.hbs | 12 +- .../DeleteDraft/deleteDraftResult.hbs | 4 +- .../extractBiometricsResult.hbs | 12 +- .../idRepository/GetDraft/getDraftResult.hbs | 14 +-- .../GetUpdateCount/GetUpdateCount.yml | 29 ++--- .../GetUpdateCount/GetUpdateCountResult.hbs | 5 - .../PublishDraft/PublishDraft.yml | 3 +- .../PublishDraft/publishDraftResult.hbs | 7 +- .../ReactivateVIDsForUIN.yml | 57 +++------ .../reactivateVIDsForUINResult.hbs | 12 +- .../RegenerateVid/RegenerateVid.yml | 15 +-- .../RegenerateVid/regenerateVidResult.hbs | 11 -- .../RetrieveAuthTypeStatus.yml | 18 +-- .../retrieveAuthTypeStatusResult.hbs | 7 +- .../RetrieveIdentityByRid.yml | 6 +- .../retrieveIdentityByRidResult.hbs | 11 +- .../RetrieveIdentityByUin.yml | 21 ++-- .../retrieveIdentityByUinResult_eng.hbs | 119 +----------------- .../retrieveIdentityByUinResult_hin.hbs | 27 +--- .../RetrieveUINByVID/RetrieveUINByVID.yml | 61 ++++----- .../retrieveUINByVIDResult.hbs | 11 +- .../RetrieveVIDByUIN/RetrieveVIDByUIN.yml | 13 +- .../retrieveVIDByUINResult.hbs | 17 +-- .../UpdateDraft/updateDraftResult.hbs | 12 +- .../UpdateIdentity/UpdateIdentity.yml | 3 +- .../UpdateIdentity/updateIdentityResult.hbs | 11 +- .../UpdateVIDStatus/UpdateVidStatus.yml | 111 ++++++---------- .../UpdateVIDStatus/UpdateVidStatusResult.hbs | 6 +- .../src/main/resources/idRepository/error.hbs | 6 +- .../idRepository/uinrids/createuinresult.hbs | 9 +- 43 files changed, 287 insertions(+), 785 deletions(-) diff --git a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml index 8e0726cab8c..c2f0bf88e96 100644 --- a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml @@ -354,8 +354,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -391,8 +390,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -465,8 +463,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -502,8 +499,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -539,8 +535,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -648,8 +643,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -716,8 +710,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -753,8 +746,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -790,8 +782,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -858,8 +849,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -895,8 +885,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -932,8 +921,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -941,6 +929,7 @@ AddIdentity: IdRepository_AddIdentity_with_Invalid_Past_Timestamp_Neg: endPoint: /idrepository/v1/identity/ role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AddIdentity/addIdentity_$LANGNUMBER$ outputTemplate: idRepository/error @@ -969,8 +958,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -1006,8 +994,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -1043,8 +1030,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -1080,8 +1066,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -1117,8 +1102,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -1154,8 +1138,7 @@ AddIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' diff --git a/automationtests/src/main/resources/idRepository/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/idRepository/AddIdentity/addIdentityResult.hbs index 720254c65ba..ca45b742b9e 100644 --- a/automationtests/src/main/resources/idRepository/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/idRepository/AddIdentity/addIdentityResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.id.create", - "version": "v1", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": [ - - ] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLock.yml b/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLock.yml index 447c112ac09..d6eb468f9a7 100644 --- a/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLock.yml +++ b/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLock.yml @@ -2,6 +2,7 @@ AuthInternalLock: IdRepository_AuthInternalLock_Uin_Demo_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -17,12 +18,13 @@ AuthInternalLock: "unlockForSeconds": 0 }' output: '{ - "responsetime": "$IGNORE$" + "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Vid_Demo_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -38,12 +40,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Uin_FACE_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -59,12 +61,13 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" + "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Vid_FACE_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -80,12 +83,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Uin_IRIS_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -101,12 +104,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Vid_IRIS_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -122,12 +125,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Uin_FINGER_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -143,12 +146,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Vid_FINGER_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -164,12 +167,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Uin_email_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -185,12 +188,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Vid_email_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -206,12 +209,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Uin_phone_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -227,12 +230,12 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Vid_phone_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalLock/authInternalLock outputTemplate: idRepository/AuthInternalLock/AuthInternalLockResult @@ -248,7 +251,6 @@ AuthInternalLock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalLock_Uin_Empty_Authtype: @@ -271,8 +273,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -297,8 +298,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -323,8 +323,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -349,8 +348,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -375,8 +373,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -401,8 +398,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -427,8 +423,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -453,8 +448,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -479,8 +473,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -505,8 +498,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -531,8 +523,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -557,8 +548,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -583,8 +573,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -609,8 +598,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -635,8 +623,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -661,8 +648,7 @@ AuthInternalLock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLockResult.hbs b/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLockResult.hbs index fa6c47257a7..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLockResult.hbs +++ b/automationtests/src/main/resources/idRepository/AuthInternalLock/AuthInternalLockResult.hbs @@ -1,8 +1,2 @@ { - "id": null, - "version": null, - "responsetime": "{{responsetime}}", - "metadata": null, - "response": null, - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlock.yml b/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlock.yml index 554a0aa6369..dd6b9d0abd1 100644 --- a/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlock.yml +++ b/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlock.yml @@ -2,6 +2,7 @@ AuthInternalUnlock: IdRepository_AuthInternalUnlock_Uin_Demo_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -17,12 +18,12 @@ AuthInternalUnlock: "unlockForSeconds": 0 }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Vid_Demo_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -38,12 +39,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Uin_FACE_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -59,12 +60,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Vid_FACE_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -80,12 +81,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Uin_IRIS_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -101,12 +102,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Vid_IRIS_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -122,12 +123,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Uin_FINGER_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -143,12 +144,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Vid_FINGER_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -164,12 +165,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Uin_email_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -185,12 +186,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Vid_email_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -206,12 +207,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Uin_phone_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -227,12 +228,12 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Vid_phone_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlock outputTemplate: idRepository/AuthInternalUnlock/AuthInternalUnlockResult @@ -248,7 +249,6 @@ AuthInternalUnlock: "requestTime": "$TIMESTAMP$" }' output: '{ - "responsetime": "$IGNORE$" }' IdRepository_AuthInternalUnlock_Uin_Empty_Authtype: @@ -271,8 +271,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -297,8 +296,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -323,8 +321,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -349,8 +346,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -375,8 +371,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -401,8 +396,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -427,8 +421,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -453,8 +446,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -479,8 +471,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -505,8 +496,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -531,8 +521,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -557,8 +546,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -583,8 +571,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -609,8 +596,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -635,8 +621,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -661,8 +646,7 @@ AuthInternalUnlock: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlockResult.hbs b/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlockResult.hbs index fa6c47257a7..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlockResult.hbs +++ b/automationtests/src/main/resources/idRepository/AuthInternalUnlock/AuthInternalUnlockResult.hbs @@ -1,8 +1,2 @@ { - "id": null, - "version": null, - "responsetime": "{{responsetime}}", - "metadata": null, - "response": null, - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml b/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml index 0fa957da49a..2ce612c6d0e 100644 --- a/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml +++ b/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml @@ -2,6 +2,7 @@ CreateDraft: IdRepository_CreateDraft_Smoke_Pos: endPoint: /idrepository/v1/identity/draft/create/{registrationId} role: idrepo + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/CreateDraft/createDraft outputTemplate: idRepository/CreateDraft/createDraftResult @@ -23,8 +24,7 @@ CreateDraft: output: '{ "errors": [ { - "errorCode": "IDR-IDC-012", - "message": "Record already exists in DB" + "errorCode": "IDR-IDC-012" } ] }' @@ -52,8 +52,7 @@ CreateDraft: output: '{ "errors": [ { - "errorCode": "IDR-IDC-012", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-012" } ] }' @@ -69,8 +68,7 @@ CreateDraft: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "Invalid Request" + "errorCode": "IDR-IDC-003" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/CreateDraft/createDraftResult.hbs b/automationtests/src/main/resources/idRepository/CreateDraft/createDraftResult.hbs index 312476fc58c..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/idRepository/CreateDraft/createDraftResult.hbs +++ b/automationtests/src/main/resources/idRepository/CreateDraft/createDraftResult.hbs @@ -1,13 +1,2 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "status": "{{status}}", - "identity": null, - "documents": null, - "verifiedAttributes": null - }, - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/CreateDraftVID/CreateDraftVID.yml b/automationtests/src/main/resources/idRepository/CreateDraftVID/CreateDraftVID.yml index 768e56b152f..ee83d4f25e7 100644 --- a/automationtests/src/main/resources/idRepository/CreateDraftVID/CreateDraftVID.yml +++ b/automationtests/src/main/resources/idRepository/CreateDraftVID/CreateDraftVID.yml @@ -25,8 +25,7 @@ CreateDraftVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vidType" + "errorCode": "IDR-IDC-002" } ] }' @@ -43,8 +42,7 @@ CreateDraftVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vidType" + "errorCode": "IDR-IDC-002" } ] }' @@ -61,8 +59,7 @@ CreateDraftVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - vidType" + "errorCode": "IDR-IDC-001" } ] }' @@ -79,8 +76,7 @@ CreateDraftVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - UIN" + "errorCode": "IDR-IDC-002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/CreateDraftVID/createDraftVIDResult.hbs b/automationtests/src/main/resources/idRepository/CreateDraftVID/createDraftVIDResult.hbs index 1680a064889..9bf8363a338 100644 --- a/automationtests/src/main/resources/idRepository/CreateDraftVID/createDraftVIDResult.hbs +++ b/automationtests/src/main/resources/idRepository/CreateDraftVID/createDraftVIDResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.vid.create", - "version": "v1", - "responsetime": "$IGNORE$", "response": { - "vidStatus": "{{vidStatus}}", - "VID": "$IGNORE$" - }, - "errors": [] + "vidStatus": "{{vidStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/CreateVID/CreateVid.yml b/automationtests/src/main/resources/idRepository/CreateVID/CreateVid.yml index 151c15a4259..84a379cea17 100644 --- a/automationtests/src/main/resources/idRepository/CreateVID/CreateVid.yml +++ b/automationtests/src/main/resources/idRepository/CreateVID/CreateVid.yml @@ -161,8 +161,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -182,8 +181,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -203,8 +201,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - requesttime" + "errorCode": "IDR-IDC-002" } ] }' @@ -224,8 +221,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -245,8 +241,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -266,8 +261,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vidType" + "errorCode": "IDR-IDC-002" } ] }' @@ -287,8 +281,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vidType" + "errorCode": "IDR-IDC-002" } ] }' @@ -308,8 +301,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -329,8 +321,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-001" } ] }' @@ -350,8 +341,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -371,8 +361,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -392,8 +381,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - requesttime" + "errorCode": "IDR-IDC-002" } ] }' @@ -413,8 +401,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -434,8 +421,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -455,8 +441,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vidType" + "errorCode": "IDR-IDC-002" } ] }' @@ -476,8 +461,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - vidType" + "errorCode": "IDR-IDC-001" } ] }' @@ -497,8 +481,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vidType" + "errorCode": "IDR-IDC-002" } ] }' @@ -518,8 +501,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -539,8 +521,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-001" } ] }' @@ -560,8 +541,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -581,8 +561,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - version" + "errorCode": "IDR-IDC-001" } ] }' @@ -602,8 +581,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -623,8 +601,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -644,8 +621,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -665,8 +641,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - vidType" + "errorCode": "IDR-IDC-001" } ] }' @@ -686,8 +661,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-001" } ] }' @@ -707,8 +681,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - version" + "errorCode": "IDR-IDC-001" } ] }' @@ -728,8 +701,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -749,8 +721,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - vidType" + "errorCode": "IDR-IDC-001" } ] }' @@ -770,8 +741,7 @@ CreateVID: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-001" } ] }' diff --git a/automationtests/src/main/resources/idRepository/CreateVID/createVidResult.hbs b/automationtests/src/main/resources/idRepository/CreateVID/createVidResult.hbs index 57d4400e238..5e95428a4f1 100644 --- a/automationtests/src/main/resources/idRepository/CreateVID/createVidResult.hbs +++ b/automationtests/src/main/resources/idRepository/CreateVID/createVidResult.hbs @@ -1,13 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "vidStatus": "{{vidStatus}}", - "restoredVid": null, - "UIN": null, - "VID": "$IGNORE$" - }, - "errors": [] + "vidStatus": "{{vidStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml b/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml index e5178a523e5..c6733f0fdf9 100644 --- a/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml +++ b/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml @@ -30,8 +30,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" + "errorCode": "IDR-IDC-007" } ] }' @@ -67,8 +66,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -87,8 +85,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-001" } ] }' @@ -108,8 +105,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -129,8 +125,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - id" + "errorCode": "IDR-IDC-002" } ] }' @@ -151,8 +146,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - UIN" + "errorCode": "IDR-IDC-001" } ] }' @@ -172,8 +166,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - UIN" + "errorCode": "IDR-IDC-002" } ] }' @@ -193,8 +186,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - UIN" + "errorCode": "IDR-IDC-002" } ] }' @@ -214,8 +206,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - UIN" + "errorCode": "IDR-IDC-002" } ] }' @@ -235,8 +226,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - requesttime" + "errorCode": "IDR-IDC-002" } ] }' @@ -255,8 +245,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -276,8 +265,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -297,8 +285,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-001" } ] }' @@ -318,8 +305,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-002" } ] }' @@ -339,8 +325,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - requesttime" + "errorCode": "IDR-IDC-002" } ] }' @@ -360,8 +345,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -380,8 +364,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - version" + "errorCode": "IDR-IDC-001" } ] }' @@ -401,8 +384,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' @@ -422,8 +404,7 @@ DeactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Missing Input Parameter - version" + "errorCode": "IDR-IDC-002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/DeactivateVid/deactivateVidResult.hbs b/automationtests/src/main/resources/idRepository/DeactivateVid/deactivateVidResult.hbs index 6bc0ad4cff3..9bf8363a338 100644 --- a/automationtests/src/main/resources/idRepository/DeactivateVid/deactivateVidResult.hbs +++ b/automationtests/src/main/resources/idRepository/DeactivateVid/deactivateVidResult.hbs @@ -1,13 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "vidStatus": "{{vidStatus}}", - "restoredVid": null, - "UIN": null, - "VID": "$IGNORE$" - }, - "errors": [] + "vidStatus": "{{vidStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/DeleteDraft/deleteDraftResult.hbs b/automationtests/src/main/resources/idRepository/DeleteDraft/deleteDraftResult.hbs index 102f5e30b2d..0137f52daaa 100644 --- a/automationtests/src/main/resources/idRepository/DeleteDraft/deleteDraftResult.hbs +++ b/automationtests/src/main/resources/idRepository/DeleteDraft/deleteDraftResult.hbs @@ -1,7 +1,5 @@ { - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/ExtractBiometrics/extractBiometricsResult.hbs b/automationtests/src/main/resources/idRepository/ExtractBiometrics/extractBiometricsResult.hbs index 312476fc58c..0137f52daaa 100644 --- a/automationtests/src/main/resources/idRepository/ExtractBiometrics/extractBiometricsResult.hbs +++ b/automationtests/src/main/resources/idRepository/ExtractBiometrics/extractBiometricsResult.hbs @@ -1,13 +1,5 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "status": "{{status}}", - "identity": null, - "documents": null, - "verifiedAttributes": null - }, - "errors": [] + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/GetDraft/getDraftResult.hbs b/automationtests/src/main/resources/idRepository/GetDraft/getDraftResult.hbs index 0e802848957..dbce335d076 100644 --- a/automationtests/src/main/resources/idRepository/GetDraft/getDraftResult.hbs +++ b/automationtests/src/main/resources/idRepository/GetDraft/getDraftResult.hbs @@ -1,15 +1,5 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "status": "{{status}}", - "identity": { - "UIN": "$IGNORE$" - }, - "documents": [], - "verifiedAttributes": null - }, - "errors": [] + "status": "{{status}}" + } } diff --git a/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCount.yml b/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCount.yml index 54c315e9762..70d3717e767 100644 --- a/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCount.yml +++ b/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCount.yml @@ -2,6 +2,7 @@ GetUpdateCount: IdRepository_GetUpdateCount_Uin_Valid_Smoke: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/GetUpdateCount/GetUpdateCount outputTemplate: idRepository/GetUpdateCount/GetUpdateCountResult @@ -28,8 +29,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -61,8 +61,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -83,6 +82,7 @@ GetUpdateCount: IdRepository_GetUpdateCount_Vid_Valid_Smoke: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/GetUpdateCount/GetUpdateCount outputTemplate: idRepository/GetUpdateCount/GetUpdateCountResult @@ -109,8 +109,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -142,8 +141,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -175,8 +173,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - idType" + "errorCode": "IDR-IDC-002" } ] }' @@ -195,8 +192,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - idType" + "errorCode": "IDR-IDC-002" } ] }' @@ -215,8 +211,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - idType" + "errorCode": "IDR-IDC-002" } ] }' @@ -235,8 +230,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - idType" + "errorCode": "IDR-IDC-002" } ] }' @@ -275,8 +269,7 @@ GetUpdateCount: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - idType" + "errorCode": "IDR-IDC-002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCountResult.hbs b/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCountResult.hbs index e968fa180df..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCountResult.hbs +++ b/automationtests/src/main/resources/idRepository/GetUpdateCount/GetUpdateCountResult.hbs @@ -1,7 +1,2 @@ { - "id": "mosip.id.read", - "version": "v1", - "errors": "$IGNORE$", - "response": "$IGNORE$", - "responseTime": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml b/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml index 9d83b9881ef..96e015b4511 100644 --- a/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml +++ b/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml @@ -23,8 +23,7 @@ PublishDraft: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" + "errorCode": "IDR-IDC-007" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/PublishDraft/publishDraftResult.hbs b/automationtests/src/main/resources/idRepository/PublishDraft/publishDraftResult.hbs index 1470e64377f..0137f52daaa 100644 --- a/automationtests/src/main/resources/idRepository/PublishDraft/publishDraftResult.hbs +++ b/automationtests/src/main/resources/idRepository/PublishDraft/publishDraftResult.hbs @@ -1,10 +1,5 @@ { - "responsetime": "$IGNORE$", - "metadata": { - "vid": "$IGNORE$" - }, "response": { "status": "{{status}}" - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml b/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml index e501fa2f6b8..919c6104cf9 100644 --- a/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml +++ b/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml @@ -18,6 +18,7 @@ ReactivateVIDs: IdRepository_ReactivateVIDs_Deactivated_Uin: endPoint: /idrepository/v1/vid/reactivate role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/ReactivateVIDsForUIN/reactivateVIDsForUIN outputTemplate: idRepository/ReactivateVIDsForUIN/reactivateVIDsForUINResult @@ -30,8 +31,6 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" } ] }' @@ -67,8 +66,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -87,8 +85,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -108,8 +105,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -129,8 +125,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -150,8 +145,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -171,8 +165,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -192,8 +185,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -213,8 +205,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -234,8 +225,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -254,8 +244,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -275,8 +264,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -296,8 +284,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -317,8 +304,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -338,8 +324,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -359,8 +344,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -379,8 +363,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -400,8 +383,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -421,8 +403,7 @@ ReactivateVIDs: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/reactivateVIDsForUINResult.hbs b/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/reactivateVIDsForUINResult.hbs index a3723e239cf..9bf8363a338 100644 --- a/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/reactivateVIDsForUINResult.hbs +++ b/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/reactivateVIDsForUINResult.hbs @@ -1,13 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "vidStatus": "{{vidStatus}}", - "restoredVid": null, - "UIN": null, - "VID": null - }, - "errors": [] + "vidStatus": "{{vidStatus}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RegenerateVid/RegenerateVid.yml b/automationtests/src/main/resources/idRepository/RegenerateVid/RegenerateVid.yml index 17f4c289af4..08a8a088120 100644 --- a/automationtests/src/main/resources/idRepository/RegenerateVid/RegenerateVid.yml +++ b/automationtests/src/main/resources/idRepository/RegenerateVid/RegenerateVid.yml @@ -2,6 +2,7 @@ RegenerateVid: IdRepository_RegenerateVid_Smoke_Pos: endPoint: /idrepository/v1/vid/{VID}/regenerate role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: idRepository/RegenerateVid/regenerateVid outputTemplate: idRepository/RegenerateVid/regenerateVidResult @@ -9,8 +10,6 @@ RegenerateVid: "VID":"$ID:CreateVID_withValidParameters_For_VidType_Smoke_Temporary_sid_VID$" }' output: '{ - "vidStatus": "ACTIVE", - "VID": "$IGNORE$" }' IdRepository_RegenerateVid_Uin_Neg: @@ -25,8 +24,7 @@ RegenerateVid: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "Invalid Input Parameter - vid" + "errorCode": "IDR-IDC-002" } ] }' @@ -43,8 +41,7 @@ RegenerateVid: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -61,8 +58,7 @@ RegenerateVid: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -79,8 +75,7 @@ RegenerateVid: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RegenerateVid/regenerateVidResult.hbs b/automationtests/src/main/resources/idRepository/RegenerateVid/regenerateVidResult.hbs index fe77716f4bc..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/idRepository/RegenerateVid/regenerateVidResult.hbs +++ b/automationtests/src/main/resources/idRepository/RegenerateVid/regenerateVidResult.hbs @@ -1,13 +1,2 @@ { - "id": "mosip.vid.regenerate", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "vidStatus": "{{vidStatus}}", - "restoredVid": null, - "UIN": null, - "VID": "{{VID}}" - }, - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml b/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml index ecd675d554c..739473ee0bb 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml @@ -41,8 +41,7 @@ RetrieveAuthTypeStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "Unknown error occurred" + "errorCode": "IDR-IDC-004" } ] }' @@ -59,8 +58,7 @@ RetrieveAuthTypeStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -77,8 +75,7 @@ RetrieveAuthTypeStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "Unknown error occurred" + "errorCode": "IDR-IDC-004" } ] }' @@ -95,8 +92,7 @@ RetrieveAuthTypeStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "Unknown error occurred" + "errorCode": "IDR-IDC-004" } ] }' @@ -113,8 +109,7 @@ RetrieveAuthTypeStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -131,8 +126,7 @@ RetrieveAuthTypeStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "Unknown error occurred" + "errorCode": "IDR-IDC-004" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/retrieveAuthTypeStatusResult.hbs b/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/retrieveAuthTypeStatusResult.hbs index 6fc8af84a34..444deca6f1e 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/retrieveAuthTypeStatusResult.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/retrieveAuthTypeStatusResult.hbs @@ -1,13 +1,8 @@ { - "responsetime": "$IGNORE$", "response": { "authTypes": [ { - "authType": "$IGNORE$", - "authSubType": "$IGNORE$", - "locked": "$IGNORE$" } ] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml index ca6e7bb3da8..bdf0f6b4f5f 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml @@ -23,8 +23,7 @@ RetrieveIdentityByRid: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-007" } ] }' @@ -52,8 +51,7 @@ RetrieveIdentityByRid: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-007" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs index 1e374a74f1c..9884f2404b8 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs @@ -1,12 +1,5 @@ { - "id": "mosip.id.read", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "status": "ACTIVATED", - "identity": "$IGNORE$", - "documents": "$IGNORE$" - }, - "errors": [] + "status": "ACTIVATED" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml index b070d11d1a5..94462fe58cd 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml @@ -53,8 +53,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" + "errorCode": "IDR-IDC-007" } ] }' @@ -81,8 +80,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" + "errorCode": "IDR-IDC-007" } ] }' @@ -109,8 +107,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" + "errorCode": "IDR-IDC-007" } ] }' @@ -127,8 +124,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-007", - "message": "No Record(s) found" + "errorCode": "IDR-IDC-007" } ] }' @@ -145,8 +141,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is DEACTIVATED" + "errorCode": "IDR-VID-001" } ] }' @@ -162,8 +157,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is DEACTIVATED" + "errorCode": "IDR-VID-001" } ] }' @@ -179,8 +173,7 @@ RetrieveIdentity: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is DEACTIVATED" + "errorCode": "IDR-VID-001" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_eng.hbs b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_eng.hbs index fc0ea0c651a..31431eb914a 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_eng.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_eng.hbs @@ -1,124 +1,8 @@ { - "id": "mosip.id.read", - "version": "v1", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}", "identity": { - "residenceStatus": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "IDSchemaVersion": $IGNORE$, "UIN": "{{UIN}}", - "fullName": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "dateOfBirth": "$IGNORE$", - "gender": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "addressLine1": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "addressLine2": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "addressLine3": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "region": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "province": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "city": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "postalCode": "$IGNORE$", - "email": "$IGNORE$", - "phone": "$IGNORE$", - "referenceIdentityNumber": "$IGNORE$", - "zone": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - } - ], - "introducerRID": "$IGNORE$", - "introducerUIN": "$IGNORE$", - "introducerName": [ - { - "language": "$IGNORE$", - "value": "$IGNORE$" - }, - { - "value": "$IGNORE$" - } - ], "proofOfAddress": { "format": "pdf", "type": "RNC", @@ -151,6 +35,5 @@ } }, "documents": [] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_hin.hbs b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_hin.hbs index ffd57f94f41..cee9f9ee58c 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_hin.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/retrieveIdentityByUinResult_hin.hbs @@ -1,7 +1,4 @@ { - "id": "mosip.id.read", - "version": "v1", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}", "identity": { @@ -16,90 +13,71 @@ "fullName": [ { "language": "hin", - "value": "$IGNORE$" }, { "language": "kan", - "value": "$IGNORE$" }, { "language": "tam", - "value": "$IGNORE$" } ], - "dateOfBirth": "$IGNORE$", "gender": [ { "language": "hin", - "value": "$IGNORE$" }, { "language": "kan", - "value": "$IGNORE$" }, { "language": "tam", - "value": "$IGNORE$" } ], "addressLine1": [ { "language": "hin", - "value": "$IGNORE$" }, { "language": "kan", - "value": "$IGNORE$" }, { "language": "tam", - "value": "$IGNORE$" } ], "addressLine2": [ { "language": "hin", - "value": "$IGNORE$" }, { "language": "kan", - "value": "$IGNORE$" }, { "language": "tam", - "value": "$IGNORE$" } ], "addressLine3": [ { "language": "hin", - "value": "$IGNORE$" }, { "language": "kan", - "value": "$IGNORE$" }, { "language": "tam", - "value": "$IGNORE$" } ], "region": [ { "language": "hin", - "value": "$IGNORE$" } ], "province": [ { "language": "hin", - "value": "$IGNORE$" } ], "city": [ { "language": "hin", - "value": "$IGNORE$" } ], "postalCode": "14022", @@ -117,11 +95,9 @@ "introducerName": [ { "language": "hin", - "value": "$IGNORE$" }, { "language": "kan", - "value": "$IGNORE$" } ], "proofOfAddress": { @@ -156,6 +132,5 @@ } }, "documents": [] - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveUINByVID/RetrieveUINByVID.yml b/automationtests/src/main/resources/idRepository/RetrieveUINByVID/RetrieveUINByVID.yml index acda71865c5..6db519b7338 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveUINByVID/RetrieveUINByVID.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveUINByVID/RetrieveUINByVID.yml @@ -2,6 +2,7 @@ Retrieve_VID_pos: IdRepository_Retrieve_VID_pos_perpetual_Active_smoke: endPoint: /idrepository/v1/vid/{VID} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveUINByVID/retrieveUINByVID outputTemplate: idRepository/RetrieveUINByVID/retrieveUINByVIDResult @@ -9,13 +10,14 @@ Retrieve_VID_pos: "VID": "$ID:CreateVID_withValidParameters_For_VidType_Smoke_Perpetual_sid_VID$" }' output: '{ - "UIN": "$IGNORE$", - "vidStatus": "$IGNORE$" + "vidStatus": "$IGNORE$", + "UIN": "$IGNORE$" }' IdRepository_Retrieve_VID_pos_Temp_Active_smoke: endPoint: /idrepository/v1/vid/{VID} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveUINByVID/retrieveUINByVID outputTemplate: idRepository/RetrieveUINByVID/retrieveUINByVIDResult @@ -23,13 +25,15 @@ Retrieve_VID_pos: "VID": "$ID:CreateVID_withValidParameters_Smoke_Temp1_sid_VID$" }' output: '{ - "UIN": "$IGNORE$", - "vidStatus": "$IGNORE$" + "vidStatus": "$IGNORE$", + "UIN": "$IGNORE$" + }' IdRepository_Retrieve_VID_pos_Onetimeuse_Active_smoke: endPoint: /idrepository/v1/vid/{VID} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveUINByVID/retrieveUINByVID outputTemplate: idRepository/RetrieveUINByVID/retrieveUINByVIDResult @@ -37,8 +41,8 @@ Retrieve_VID_pos: "VID": "$ID:CreateVID_withValidParameters_Smoke_Onetime_sid_VID$" }' output: '{ - "UIN": "$IGNORE$", - "vidStatus": "$IGNORE$" + "vidStatus": "$IGNORE$", + "UIN": "$IGNORE$" }' IdRepository_Retrieve_VID_pos_perpetual_DEACTIVATED: @@ -53,8 +57,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is DEACTIVATED" + "errorCode": "IDR-VID-001" } ] }' @@ -71,8 +74,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is DEACTIVATED" + "errorCode": "IDR-VID-001" } ] }' @@ -89,8 +91,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is EXPIRED" + "errorCode": "IDR-VID-001" } ] }' @@ -106,8 +107,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is REVOKED" + "errorCode": "IDR-VID-001" } ] }' @@ -123,8 +123,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is DEACTIVATED" + "errorCode": "IDR-VID-001" } ] }' @@ -140,8 +139,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-VID-001", - "message": "VID is REVOKED" + "errorCode": "IDR-VID-001" } ] }' @@ -158,8 +156,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -176,8 +173,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -194,8 +190,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -212,8 +207,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -230,8 +224,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -248,8 +241,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -266,8 +258,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -284,8 +275,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -302,8 +292,7 @@ Retrieve_VID_pos: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveUINByVID/retrieveUINByVIDResult.hbs b/automationtests/src/main/resources/idRepository/RetrieveUINByVID/retrieveUINByVIDResult.hbs index 754f25640eb..efbd5b20f98 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveUINByVID/retrieveUINByVIDResult.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveUINByVID/retrieveUINByVIDResult.hbs @@ -1,13 +1,6 @@ { - "id": "mosip.vid.read", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": null, "response": { "vidStatus": "{{vidStatus}}", - "restoredVid": null, - "UIN": "{{UIN}}", - "VID": null - }, - "errors": [] + "UIN": "{{UIN}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml index 338158a1855..ea502b01e92 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml @@ -10,6 +10,7 @@ RetrieveVIDByUIN: "UIN":"$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$" }' output: '{ + "vidType": "$IGNORE$" }' IdRepository_RetrieveVIDByUIN_With_Valid_Smoke_Perp: endPoint: /idrepository/v1/vid/uin/{UIN} @@ -22,6 +23,8 @@ RetrieveVIDByUIN: "UIN":"$ID:AddIdentity_ValidParam_smoke_Pos_UIN$" }' output: '{ + "vidType": "$IGNORE$" + }' IdRepository_RetrieveVIDByUIN_With_All_Vid_Valid_Smoke: @@ -35,6 +38,7 @@ RetrieveVIDByUIN: "UIN":"$ID:AddIdentity_For_NewScen_smoke_Pos_UIN$" }' output: '{ + "vidType": "$IGNORE$" }' IdRepository_RetrieveVIDByUIN_With_Invalid Uin: @@ -49,8 +53,7 @@ RetrieveVIDByUIN: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' @@ -67,8 +70,7 @@ RetrieveVIDByUIN: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -85,8 +87,7 @@ RetrieveVIDByUIN: output: '{ "errors": [ { - "errorCode": "IDR-IDC-004", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-004" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult.hbs b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult.hbs index 8e04d0f6e3a..f59441a2c14 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult.hbs @@ -1,20 +1,7 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": [ { - "vid": "$IGNORE$", - "vidType": "{{vidType}}", - "expiryTimestamp": "$IGNORE$", - "transactionLimit": $IGNORE$, - "hashAttributes": { - "SALT": "$IGNORE$", - "MODULO": "$IGNORE$", - "id_hash": "$IGNORE$" - } + "vidType": "{{vidType}}" } - ], - "errors": [] + ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/UpdateDraft/updateDraftResult.hbs b/automationtests/src/main/resources/idRepository/UpdateDraft/updateDraftResult.hbs index 312476fc58c..0137f52daaa 100644 --- a/automationtests/src/main/resources/idRepository/UpdateDraft/updateDraftResult.hbs +++ b/automationtests/src/main/resources/idRepository/UpdateDraft/updateDraftResult.hbs @@ -1,13 +1,5 @@ { - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "status": "{{status}}", - "identity": null, - "documents": null, - "verifiedAttributes": null - }, - "errors": [] + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml b/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml index 2ada083e1ef..6054e5cf760 100644 --- a/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml +++ b/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml @@ -281,8 +281,7 @@ UpdateIdentity: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' diff --git a/automationtests/src/main/resources/idRepository/UpdateIdentity/updateIdentityResult.hbs b/automationtests/src/main/resources/idRepository/UpdateIdentity/updateIdentityResult.hbs index 4ebe34ae861..ca45b742b9e 100644 --- a/automationtests/src/main/resources/idRepository/UpdateIdentity/updateIdentityResult.hbs +++ b/automationtests/src/main/resources/idRepository/UpdateIdentity/updateIdentityResult.hbs @@ -1,12 +1,5 @@ { - "id": "mosip.id.update", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "status": "{{status}}", - "identity": null, - "documents": null - }, - "errors": [] + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml index 43f8b40180f..9283a3406aa 100644 --- a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml +++ b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml @@ -15,8 +15,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -36,8 +35,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -57,8 +55,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -78,8 +75,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -99,8 +95,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -120,8 +115,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -141,8 +135,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -162,8 +155,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -199,8 +191,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -220,8 +211,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -241,8 +231,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -262,8 +251,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -283,8 +271,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -304,8 +291,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -325,8 +311,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -346,8 +331,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -367,8 +351,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -388,8 +371,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -409,8 +391,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -430,8 +411,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -451,8 +431,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -472,8 +451,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -493,8 +471,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -514,8 +491,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -535,8 +511,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -556,8 +531,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -577,8 +551,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -598,8 +571,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -619,8 +591,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -640,8 +611,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-001", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-001" } ] }' @@ -661,8 +631,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -682,8 +651,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -704,8 +672,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -726,8 +693,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-003", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-003" } ] }' @@ -748,8 +714,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -770,8 +735,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' @@ -792,8 +756,7 @@ UpdateVidStatus: output: '{ "errors": [ { - "errorCode": "IDR-IDC-002", - "message": "$IGNORE$" + "errorCode": "IDR-IDC-002" } ] }' diff --git a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs index 6a2647327e5..9bf8363a338 100644 --- a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs +++ b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "vidStatus": "{{vidStatus}}" - }, - "errors": [] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/error.hbs b/automationtests/src/main/resources/idRepository/error.hbs index 04f0f8e99d2..f4bcb6bee67 100644 --- a/automationtests/src/main/resources/idRepository/error.hbs +++ b/automationtests/src/main/resources/idRepository/error.hbs @@ -1,12 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "message": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/idRepository/uinrids/createuinresult.hbs b/automationtests/src/main/resources/idRepository/uinrids/createuinresult.hbs index 720254c65ba..67a058e0dd3 100644 --- a/automationtests/src/main/resources/idRepository/uinrids/createuinresult.hbs +++ b/automationtests/src/main/resources/idRepository/uinrids/createuinresult.hbs @@ -1,11 +1,6 @@ { - "id": "mosip.id.create", - "version": "v1", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": [ - - ] + } + } \ No newline at end of file From dd23c174db26e265475430f7bdbc804734d81a9f Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 29 Aug 2023 12:34:29 +0530 Subject: [PATCH 090/204] MOSIP-29104 MOSIP-29082 --- .../AcknowledgementController.yml | 15 ++ .../AcknowledgementControllerResult.hbs | 10 +- .../AddIdentity/addIdentityResult.hbs | 8 +- .../resources/resident/AuditLog/AuditLog.yml | 2 + .../AuditLog/createAuditLogResult.hbs | 10 +- .../resident/AuthHistory/AuthHistory.yml | 21 ++- .../AuthHistory/authHistoryResult.hbs | 11 +- .../resident/AuthLock/createAuthLock.yml | 60 ++++--- .../AuthLock/createAuthLockResult.hbs | 12 +- .../AuthLockNew/CreateAuthLockNewResult.hbs | 10 +- .../resident/AuthUnLock/createAuthUnLock.yml | 73 +++++--- .../AuthUnLock/createAuthUnLockResult.hbs | 12 +- .../CreateAuthUnlockNewResult.hbs | 10 +- .../AuthenticateUserResult.hbs | 10 +- .../AuthorizationCode/AuthorizationCode.yml | 2 - .../AuthorizationCodeResult.hbs | 12 +- .../CheckAidStatus/CheckAidStatus.yml | 7 + .../CheckAidStatus/CheckAidStatusResult.hbs | 14 +- .../CancellCredential/CancellCredential.yml | 3 +- .../cancellcredentialResult.hbs | 12 +- .../CredentialCheckStatus.yml | 12 -- .../credentialcheckstatusResult.hbs | 9 +- .../GetCredentialTypes/GetCredentialTypes.yml | 3 - .../getCredentialTypesResult.hbs | 21 +-- .../getPolicyByCredentialTypeResult.hbs | 22 +-- .../GetRqstId/getRqstIdResult.hbs | 11 +- .../RequestCredentials/ReqCredential.yml | 104 +++++++---- .../ReqCredentialResult.hbs | 12 +- .../DeleteDoc/DeleteDoc.yml | 6 +- .../DeleteDoc/DeleteDocResult.hbs | 10 +- .../GetDocByDocId/GetDocByDocId.yml | 7 + .../GetDocByDocId/GetDocByDocIdResult.hbs | 11 +- .../GetDocByTransId/GetDocByTransIdResult.hbs | 14 +- .../UploadDocument/UploadDocumentResult.hbs | 7 +- .../DownloadNearestRegCen.yml | 6 + .../DownloadNearestRegCenResult.hbs | 11 +- .../DownloadRegCenterDetails.yml | 5 + .../DownloadRegCenterDetailsResult.hbs | 11 +- .../DownloadServiceHistory.yml | 17 ++ .../DownloadServiceHistoryResult.hbs | 19 +- .../DownloadSupportingDocs.yml | 6 + .../DownloadSupportingDocsResult.hbs | 11 +- .../DownloadUinCard/DownloadUinCard.yml | 7 + .../DownloadUinCard/DownloadUinCardResult.hbs | 9 +- .../DownloadUinCardByEventId.yml | 6 + .../DownloadUinCardByEventIdResult.hbs | 11 +- .../GenerateToken/GenerateTokenResult.hbs | 5 +- .../GenerateVID/createGenerateVID.yml | 169 ++++++++---------- .../GenerateVID/createGenerateVIDNew.yml | 16 -- .../createGenerateVIDNewResult.hbs | 10 +- .../GenerateVID/createGenerateVIDResult.hbs | 11 +- ...lTemplateBylangCodeAndTemplateTypeCode.yml | 11 ++ ...ateBylangCodeAndTemplateTypeCodeResult.hbs | 10 +- .../GetAuthLockStatus/GetAuthLockStatus.yml | 3 + .../getAuthLockStatusResult.hbs | 10 +- ...hannelVerificationStatusNegativeResult.hbs | 7 +- .../getChannelVerificationStatusResult.hbs | 7 +- .../GetCheckEventIdStatus.yml | 6 + .../GetCheckEventIdStatusResult.hbs | 10 +- ...inateSpecificRegistrationCentersResult.hbs | 37 +--- .../GetDocumentTypesResult.hbs | 9 +- .../resident/GetGenderCode/GetGenderCode.yml | 5 + .../GetGenderCode/GetGenderCodeResult.hbs | 9 +- .../GetIdentityMapping/GetIdentityMapping.yml | 1 + .../getIdentityMappingResult.hbs | 9 +- ...tImmediateChildrenByLocCodeAndLangCode.yml | 14 +- ...iateChildrenByLocCodeAndLangCodeResult.hbs | 84 +-------- .../GetInputAttributeValues.yml | 7 + .../getInputAttributeValuesResult.hbs | 10 +- .../GetLastClickNotification.yml | 3 + .../GetLastClickNotificationResult.hbs | 7 +- .../GetLatestIdSchema/GetLatestIdSchema.yml | 2 + .../getLatestIdSchemaResult.hbs | 36 +--- ...GetLocationDetailsByLocCodeAndLangCode.yml | 26 +-- ...ationDetailsByLocCodeAndLangCodeResult.hbs | 23 +-- .../GetLocationHierarchyByLangCode.yml | 7 +- .../getLocationHierarchyByLangCodeResult.hbs | 48 +---- .../GetNotifications/GetNotifications.yml | 34 ++-- .../GetNotificationsResult.hbs | 10 +- .../GetOrderStatus/GetOrderStatusResult.hbs | 4 +- .../GetPartnersByPartnerType.yml | 6 + .../getPartnersByPartnerTypeResult.hbs | 10 +- ...orMappedPartnerAndCredentialtypeResult.hbs | 34 +--- .../resident/GetProfile/GetProfile.yml | 3 + .../resident/GetProfile/GetProfileResult.hbs | 11 +- ...etRegCenterByLangCodeAndHierarchyLevel.yml | 37 ++-- ...enterByLangCodeAndHierarchyLevelResult.hbs | 37 +--- ...CenterByHierarchyLevelAndTextPaginated.yml | 20 +++ ...ByHierarchyLevelAndTextPaginatedResult.hbs | 50 +----- .../GetRegistrationCenterWorkingDays.yml | 7 +- ...getRegistrationCenterWorkingDaysResult.hbs | 42 +---- ...ainingupdatecountbyIndividualIdRequest.yml | 4 + ...updatecountbyIndividualIdRequestResult.hbs | 8 +- ...iningupdatecountbyIndividualIdRequest2.yml | 3 + ...pdatecountbyIndividualIdRequest2Result.hbs | 9 +- .../GetRequestCardVid/GetRequestCardVid.yml | 4 +- .../GetRequestCardVidResult.hbs | 7 +- .../GetResidentValidDocuments.yml | 10 +- .../getResidentValidDocumentsResult.hbs | 63 +------ .../GetRetrieveVidPolicy.yml | 2 + .../getRetrieveVidPolicyResult.hbs | 9 +- .../GetRidByIndividualId.yml | 4 + .../GetRidByIndividualIdResult.hbs | 10 +- .../GetServiceHistory/GetServiceHistory.yml | 85 +++++++++ .../GetServiceHistoryResult.hbs | 27 +-- .../GetSupportingDoc/GetSupportingDoc.yml | 2 + .../GetSupportingDocResult.hbs | 11 +- .../GetUiProperties/GetUiProperties.yml | 11 +- .../GetUiProperties/getUiPropertiesResult.hbs | 19 +- .../GetValidDocumentByLangCode.yml | 6 +- .../getValidDocumentByLangCodeResult.hbs | 34 +--- .../GetValidateToken/GetValidateToken.yml | 4 + .../getValidateTokenResult.hbs | 10 +- .../GrievanceTicket/GrievanceTicket.yml | 16 ++ .../GrievanceTicket/GrievanceTicketResult.hbs | 10 +- .../resources/resident/LoginUri/LoginUri.yml | 1 + .../resident/LoginUri/LoginUriResult.hbs | 11 +- .../OAuthDetailsRequestResult.hbs | 17 +- .../resident/PRINTUIN/createPrintUin.yml | 19 +- .../PRINTUIN/createPrintUinResult.hbs | 12 +- .../PersonalizedCard/PersonalizedCard.yml | 8 + .../PersonalizedCardResult.hbs | 14 +- .../resident/PinStatus/PinStatus.yml | 6 +- .../resident/PinStatus/PinStatusResult.hbs | 10 +- .../PutBellUpdatedTime/PutBellUpdatedTime.yml | 2 + .../PutBellUpdatedTimeResult.hbs | 7 +- .../resident/ReqAidOtp/ReqAidOtpResult.hbs | 8 +- .../ReqShareCredWithPartnerResult.hbs | 7 +- .../resident/RetrieveVID/RetrieveVID.yml | 3 + .../RetrieveVID/RetrieveVIDResult.hbs | 21 +-- .../resident/RevokeVID/createRevokeVID.yml | 36 +++- .../RevokeVID/createRevokeVIDResult.hbs | 10 +- .../RevokeVIDNew/CreateRevokeVIDNew.yml | 12 +- .../RevokeVIDNew/CreateRevokeVIDNewResult.hbs | 10 +- .../RidCheckStatus/createRidCheckStatus.yml | 8 +- .../createRidCheckStatusResult.hbs | 7 +- .../SendOTP/createSendOTPErrorResult.hbs | 9 +- .../SendOTP/createSendOTPErrorResult2.hbs | 9 +- .../resident/SendOTP/createSendOTPResult.hbs | 8 +- .../SendOTP/createSendOTPResultForEmail.hbs | 8 +- .../SendOTP/createSendOTPResultForPhone.hbs | 8 +- .../resident/SendOTPUIN/createSendOTP.yml | 1 + .../SendOTPUIN/createSendOTPResult.hbs | 8 +- .../SendOtpForContactDetResult.hbs | 10 +- .../SendOtpForExpirationResult.hbs | 11 +- .../SendOtpForVid/createSendOTPResult.hbs | 8 +- .../resident/SendOtpIdp/SendOtpIdp.yml | 3 +- .../resident/SendOtpIdp/SendOtpIdpResult.hbs | 7 +- .../SendOtpToUserId/SendOtpToUserId.yml | 18 +- .../SendOtpToUserId/SendOtpToUserIdResult.hbs | 9 +- .../resources/resident/SignJWT/SignJWT.yml | 1 - .../resident/SignJWT/SignJWTResult.hbs | 6 +- .../TranslitrateData/TranslitrateData.yml | 19 ++ .../TranslitrateDataResult.hbs | 12 +- .../resident/UnPinStatus/UnPinStatus.yml | 6 +- .../UnPinStatus/UnPinStatusResult.hbs | 10 +- .../UpdateContactDetailsResult.hbs | 9 +- .../resident/UpdateUIN/UpdateUIN.yml | 16 +- .../resident/UpdateUIN/UpdateUinResult.hbs | 12 +- .../resident/UpdateUINNew/UpdateUINNew.yml | 12 +- .../UpdateUINNew/UpdateUINNewResult.hbs | 10 +- .../ValidateExpiredOTP/ValidateExpiredOTP.yml | 4 +- .../ValidateExpiredOTPResult.hbs | 10 -- .../ValidateOTP/ValidateOTPResult.hbs | 6 +- .../ValidateWithUserIdOtp.yml | 6 +- .../ValidateWithUserIdOtpResult.hbs | 9 +- .../src/main/resources/resident/error.hbs | 10 +- .../testNgXmlFiles/residentApi.xml | 14 +- 168 files changed, 827 insertions(+), 1658 deletions(-) delete mode 100644 automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTPResult.hbs diff --git a/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementController.yml b/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementController.yml index b11b539f4cf..7c3367d926a 100644 --- a/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementController.yml +++ b/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementController.yml @@ -2,6 +2,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_Valid_Smoke: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/AcknowledgementController/AcknowledgementControllerResult @@ -16,6 +17,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_Valid_Smoke: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/AcknowledgementController/AcknowledgementControllerResult @@ -30,6 +32,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_Invalid_languageCode_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -44,6 +47,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_Invalid_eventId_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -58,6 +62,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_Empty_languageCode_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -72,6 +77,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_spaceVal_languagecode_Neg: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/AcknowledgementController/AcknowledgementControllerResult @@ -86,6 +92,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_SpaceVal_enentId_Neg: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/AcknowledgementController/AcknowledgementControllerResult @@ -100,6 +107,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_Empty_eventId_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -114,6 +122,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_uin_Invalid_Role_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -128,6 +137,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_Invalid_languageCode_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -142,6 +152,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_Invalid_eventId_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -156,6 +167,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_Empty_languageCode_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -170,6 +182,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_Empty_eventId_Negative: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/error @@ -184,6 +197,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_SpaceVal_languageCode_Neg: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/AcknowledgementController/AcknowledgementControllerResult @@ -198,6 +212,7 @@ GetAcknowledgementController: Resident_GetAuthorizationtoken_vid_SpaceVal_eventId_Neg: endPoint: /resident/v1/ack/download/pdf/event/{eventId}/language/{languageCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/AcknowledgementController/AcknowledgementController outputTemplate: resident/AcknowledgementController/AcknowledgementControllerResult diff --git a/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementControllerResult.hbs b/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementControllerResult.hbs index 38b95b914e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementControllerResult.hbs +++ b/automationtests/src/main/resources/resident/AcknowledgementController/AcknowledgementControllerResult.hbs @@ -1,9 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs index f972c850e57..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": [ - - ] + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuditLog/AuditLog.yml b/automationtests/src/main/resources/resident/AuditLog/AuditLog.yml index fdd278a8218..858f9129053 100644 --- a/automationtests/src/main/resources/resident/AuditLog/AuditLog.yml +++ b/automationtests/src/main/resources/resident/AuditLog/AuditLog.yml @@ -2,6 +2,7 @@ AuditLog: Resident_AuditLog_StatusCode_uin_all_Valid_Smoke: endPoint: /resident/v1/auth-proxy/audit/log role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuditLog/createAuditLog outputTemplate: resident/AuditLog/createAuditLogResult @@ -28,6 +29,7 @@ AuditLog: Resident_AuditLog_StatusCode_vid_all_Valid_Smoke: endPoint: /resident/v1/auth-proxy/audit/log role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuditLog/createAuditLog outputTemplate: resident/AuditLog/createAuditLogResult diff --git a/automationtests/src/main/resources/resident/AuditLog/createAuditLogResult.hbs b/automationtests/src/main/resources/resident/AuditLog/createAuditLogResult.hbs index 38b95b914e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AuditLog/createAuditLogResult.hbs +++ b/automationtests/src/main/resources/resident/AuditLog/createAuditLogResult.hbs @@ -1,9 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml index 4fd51049b71..c765c0eb055 100644 --- a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml +++ b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml @@ -2,6 +2,7 @@ AuthHistory: Resident_AuthHistory_With_UIN_smoke_Pos: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/AuthHistory/authHistoryResult @@ -23,7 +24,6 @@ AuthHistory: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -33,6 +33,7 @@ AuthHistory: Resident_AuthHistory_With_VID_smoke_Pos: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/AuthHistory/authHistoryResult @@ -54,7 +55,6 @@ AuthHistory: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -64,6 +64,7 @@ AuthHistory: Resident_AuthHistory_InValid_UIN_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -87,7 +88,7 @@ AuthHistory: output: '{ "errors": [ { - "errorCode": "RES-SER-410", + "errorCode": "RES-SER-417", "message": "$IGNORE$" } ], @@ -100,6 +101,7 @@ AuthHistory: Resident_AuthHistory_missing_UIN_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -137,6 +139,7 @@ AuthHistory: Resident_AuthHistory_Missing_OTP_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -173,6 +176,7 @@ AuthHistory: Resident_AuthHistory_TransactionMismatch_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -209,6 +213,7 @@ AuthHistory: Resident_AuthHistory_Invalid_Id_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -245,6 +250,7 @@ AuthHistory: Resident_AuthHistory_Missing_Id_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -281,6 +287,7 @@ AuthHistory: Resident_AuthHistory_InValid_version_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -317,6 +324,7 @@ AuthHistory: Resident_AuthHistory_Missing_version_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -353,6 +361,7 @@ AuthHistory: Resident_AuthHistory_Invalid_Timestamp_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -389,6 +398,7 @@ AuthHistory: Resident_AuthHistory_Missing_Timestamp_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -426,6 +436,7 @@ AuthHistory: Resident_AuthHistory_InValid_OTP_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error @@ -463,6 +474,7 @@ AuthHistory: Resident_AuthHistory_With_UIN_Phone_smoke_Pos: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/AuthHistory/authHistoryResult @@ -484,7 +496,6 @@ AuthHistory: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForPhone" @@ -516,7 +527,6 @@ AuthHistory: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForEmail", "maskedEmail": "$IGNORE$" @@ -525,6 +535,7 @@ AuthHistory: Resident_AuthHistory_With_UIN_EmptyChannel_Neg: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/AuthHistory/authHistoryResult.hbs b/automationtests/src/main/resources/resident/AuthHistory/authHistoryResult.hbs index f69bf015966..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AuthHistory/authHistoryResult.hbs +++ b/automationtests/src/main/resources/resident/AuthHistory/authHistoryResult.hbs @@ -1,10 +1 @@ -{ - "id": "mosip.resident.authhistory", - "version": "v1", - "responsetime": "$IGNORE$", - "response": { - "authHistory": "$IGNORE$", - "message": "{{message}}" - }, - "errors": [] -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml index 24f1ab652f5..678b334dc09 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml @@ -3,6 +3,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -24,8 +25,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -37,6 +36,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -58,8 +58,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -71,6 +69,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -92,8 +91,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -104,6 +101,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -125,8 +123,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -137,6 +133,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -158,8 +155,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -170,6 +165,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -191,8 +187,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -203,6 +197,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -224,8 +219,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -236,6 +229,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -257,8 +251,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -269,6 +261,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -290,8 +283,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -302,6 +293,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -323,8 +315,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -335,6 +325,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -356,8 +347,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -368,6 +357,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -405,6 +395,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -442,6 +433,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -479,6 +471,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -517,6 +510,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -555,6 +549,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -592,6 +587,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -629,6 +625,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -666,6 +663,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -703,6 +701,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -740,6 +739,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -777,6 +777,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -815,6 +816,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -853,6 +855,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -890,6 +893,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -927,6 +931,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -964,6 +969,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -1002,6 +1008,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ @@ -1040,6 +1047,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -1074,6 +1082,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -1095,8 +1104,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForPhone" @@ -1106,8 +1113,8 @@ AuthLock: Resident_AuthLock_Valid_UIN_Email_All: endPoint: /resident/v1/req/auth-lock role: resident - checkErrorsOnlyInResponse: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult input: '{ @@ -1129,8 +1136,6 @@ AuthLock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForEmail", "maskedEmail": "$IGNORE$" @@ -1141,6 +1146,7 @@ AuthLock: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/error input: '{ diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLockResult.hbs b/automationtests/src/main/resources/resident/AuthLock/createAuthLockResult.hbs index 2dfc65607e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLockResult.hbs +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLockResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "status": "$IGNORE$", - "message": "{{message}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthLockNew/CreateAuthLockNewResult.hbs b/automationtests/src/main/resources/resident/AuthLockNew/CreateAuthLockNewResult.hbs index c20d0003c25..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/AuthLockNew/CreateAuthLockNewResult.hbs +++ b/automationtests/src/main/resources/resident/AuthLockNew/CreateAuthLockNewResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml index 0647cdf5fa0..6733b438b65 100644 --- a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml @@ -3,6 +3,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -25,8 +26,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -38,6 +37,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -60,8 +60,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -73,6 +71,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -112,6 +111,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -151,6 +151,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -173,8 +174,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -186,6 +185,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -225,6 +225,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -247,8 +248,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -260,6 +259,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -299,6 +299,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -321,8 +322,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -334,6 +333,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -373,6 +373,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -395,8 +396,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -408,6 +407,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -447,6 +447,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -469,8 +470,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -482,6 +481,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -521,6 +521,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -543,8 +544,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -556,6 +555,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -595,6 +595,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -617,8 +618,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -630,6 +629,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -669,6 +669,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -691,8 +692,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -704,6 +703,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -743,6 +743,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -782,6 +783,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -821,6 +823,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -859,6 +862,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -897,6 +901,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -935,6 +940,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -973,6 +979,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1011,6 +1018,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1049,6 +1057,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1087,6 +1096,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1125,6 +1135,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1163,6 +1174,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1201,6 +1213,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1240,6 +1253,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1279,6 +1293,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -1301,8 +1316,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1314,6 +1327,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -1336,8 +1350,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1349,6 +1361,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1388,6 +1401,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1427,6 +1441,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1466,6 +1481,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1505,6 +1521,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1544,6 +1561,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/error input: '{ @@ -1586,8 +1604,8 @@ AuthUnlock: Resident_AuthUnLock_Valid_UIN_EmailChannel_Pos: endPoint: /resident/v1/req/auth-unlock role: resident - checkErrorsOnlyInResponse: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -1610,8 +1628,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForEmail", "maskedEmail": "$IGNORE$" @@ -1622,6 +1638,7 @@ AuthUnlock: endPoint: /resident/v1/req/auth-unlock role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult input: '{ @@ -1644,8 +1661,6 @@ AuthUnlock: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForPhone", "maskedMobile": "XXXXXX3210" diff --git a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLockResult.hbs b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLockResult.hbs index 2dfc65607e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLockResult.hbs +++ b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLockResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "status": "$IGNORE$", - "message": "{{message}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthUnlockNew/CreateAuthUnlockNewResult.hbs b/automationtests/src/main/resources/resident/AuthUnlockNew/CreateAuthUnlockNewResult.hbs index e98fa6d1c04..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/AuthUnlockNew/CreateAuthUnlockNewResult.hbs +++ b/automationtests/src/main/resources/resident/AuthUnlockNew/CreateAuthUnlockNewResult.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUserResult.hbs b/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUserResult.hbs index a779613198a..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUserResult.hbs +++ b/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUserResult.hbs @@ -1,9 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$" - }, - "errors": [] -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml b/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml index ef8995da502..db902bfb774 100644 --- a/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml +++ b/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml @@ -15,7 +15,6 @@ AuthorizationCode: "permittedAuthorizeScopes": [{scope: "Manage-Identity-Data"},{scope: "Manage-VID"},{scope: "Manage-Authentication"},{scope: "Manage-Service-Requests"},{scope: "Manage-Credentials"}] }' output: '{ - "redirectUri": "$IGNORE$" }' Resident_ESignet_AuthorizationCode_Vid_All_Valid_Smoke_sid: @@ -35,5 +34,4 @@ AuthorizationCode: }' output: '{ - "redirectUri": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCodeResult.hbs b/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCodeResult.hbs index 7025d544f5b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCodeResult.hbs +++ b/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCodeResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "nonce": "$IGNORE$", - "code": "$IGNORE$", - "redirectUri": "{{redirectUri}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatus.yml b/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatus.yml index f7cc237e646..e227f409551 100644 --- a/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatus.yml +++ b/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatus.yml @@ -3,6 +3,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/CheckAidStatus/CheckAidStatusResult input: '{ @@ -32,6 +33,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/error input: '{ @@ -67,6 +69,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/error input: '{ @@ -102,6 +105,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/error input: '{ @@ -137,6 +141,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/error input: '{ @@ -172,6 +177,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/error input: '{ @@ -207,6 +213,7 @@ CheckAidStatus: endPoint: /resident/v1/aid/status role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CheckAidStatus/CheckAidStatus outputTemplate: resident/error input: '{ diff --git a/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatusResult.hbs b/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatusResult.hbs index 5da9a1ea5d4..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatusResult.hbs +++ b/automationtests/src/main/resources/resident/CheckAidStatus/CheckAidStatusResult.hbs @@ -1,13 +1 @@ -{ - "id": "mosip.resident.checkstatus", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "individualId": "$IGNORE$", - "transactionId": "$IGNORE$", - "transactionStage": "$IGNORE$", - "aidStatus": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/CancellCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/CancellCredential.yml index 514403dff69..68d82fed442 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/CancellCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/CancellCredential.yml @@ -2,6 +2,7 @@ CancellCredential: Resident_CredentialsStatus_euin_All_Valid_Smoke: endPoint: /resident/v1/req/credential/cancel/{requestId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/CredentialIssuance/CancellCredential/cancellcredential outputTemplate: resident/CredentialIssuance/CancellCredential/cancellcredentialResult @@ -9,6 +10,4 @@ CancellCredential: "requestId": "$ID:RequestCredentials_Qrcode_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/cancellcredentialResult.hbs b/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/cancellcredentialResult.hbs index 6e063e893a8..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/cancellcredentialResult.hbs +++ b/automationtests/src/main/resources/resident/CredentialIssuance/CancellCredential/cancellcredentialResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "requestId": "{{requestId}}", - "id": "{{id}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml b/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml index 1888cc096f3..7ff8c49888b 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml @@ -9,8 +9,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_euin_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' Resident_CredentialsStatus_uin_All_Valid_Smoke: @@ -23,8 +21,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_printUIN_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' Resident_CredentialsStatus_QRcode_All_Valid_Smoke: @@ -37,8 +33,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_Qrcode_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' Resident_CredentialsStatus_Of_VID_euin_All_Valid_Smoke: @@ -51,8 +45,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_euin_VID_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' Resident_CredentialsStatus_Of_VID_Reprint_All_Valid_Smoke: @@ -65,8 +57,6 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_reprint_VID_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' Resident_CredentialsStatus_Of_VID_QRcode_All_Valid_Smoke: @@ -79,7 +69,5 @@ CredentialsStatus: "requestId": "$ID:RequestCredentials_Qrcode_VID_All_Valid_Smoke_sid_requestId$" }' output: '{ - "id": "$IGNORE$", - "requestId": "$IGNORE$", "statusCode": "printing" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs b/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs index c454c7cd21a..5bd4b5fb05f 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs +++ b/automationtests/src/main/resources/resident/CredentialIssuance/CredentialCheckStatus/credentialcheckstatusResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { - "id": "{{id}}", - "requestId": "{{requestId}}", "statusCode": "{{statusCode}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml b/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml index 598d4973683..d6bad9eab15 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml @@ -9,9 +9,6 @@ GetCredentialTypes: input: '{ }' output: '{ -"response": [{ - "version": $IGNORE$ - }] }' Resident_GetCredentialTypes_all_valid_smoke: endPoint: /resident/v1/credential/types diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/getCredentialTypesResult.hbs b/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/getCredentialTypesResult.hbs index d27e9f5e16b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/getCredentialTypesResult.hbs +++ b/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/getCredentialTypesResult.hbs @@ -1,20 +1 @@ -{ - "id": "$IGNORE$", - "version": "{{version}}", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "credentialTypes": [ - {{#each credentialTypes}} - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "issuers": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": $IGNORE$ -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/GetPolicyByCredentialType/getPolicyByCredentialTypeResult.hbs b/automationtests/src/main/resources/resident/CredentialIssuance/GetPolicyByCredentialType/getPolicyByCredentialTypeResult.hbs index 06f0c7266bc..a741428fa90 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/GetPolicyByCredentialType/getPolicyByCredentialTypeResult.hbs +++ b/automationtests/src/main/resources/resident/CredentialIssuance/GetPolicyByCredentialType/getPolicyByCredentialTypeResult.hbs @@ -1,26 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", "credentialType": "{{credentialType}}", - "policyId": "$IGNORE$", - "policyName": "$IGNORE$", - "policyDesc": "$IGNORE$", - "policyType": "$IGNORE$", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", - "is_Active": $IGNORE$, - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", - "policies": "$IGNORE$" - }, - "errors": $IGNORE$ + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/GetRqstId/getRqstIdResult.hbs b/automationtests/src/main/resources/resident/CredentialIssuance/GetRqstId/getRqstIdResult.hbs index 85e5747d2b1..db78989df35 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/GetRqstId/getRqstIdResult.hbs +++ b/automationtests/src/main/resources/resident/CredentialIssuance/GetRqstId/getRqstIdResult.hbs @@ -1,15 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, "response": { "pageNo": "{{pageNo}}", "pageSize": "{{pageSize}}", - "sort": "$IGNORE$", - "totalItems": "$IGNORE$", - "totalPages": "$IGNORE$", - "data": "$IGNORE$" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml index 10861aecc8d..4bd264295fa 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -3,6 +3,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -24,7 +25,6 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -35,6 +35,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -56,7 +57,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -67,6 +68,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -88,7 +90,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -99,6 +101,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -136,6 +139,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -173,6 +177,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -194,7 +199,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -205,6 +210,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -225,7 +231,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -236,6 +242,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -256,7 +263,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -267,6 +274,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -287,7 +295,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -298,6 +306,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -319,7 +328,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -330,6 +339,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -350,7 +360,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -361,6 +371,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -381,7 +392,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -392,6 +403,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -428,6 +440,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -464,6 +477,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -500,6 +514,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -536,6 +551,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -572,6 +588,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -592,7 +609,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -603,6 +620,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -623,7 +641,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -634,6 +652,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -654,7 +673,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -664,8 +683,8 @@ RequestCredentials: Resident_RequestCredentials_encrypt_false_smoke: endPoint: /resident/v1/req/credential role: resident - checkErrorsOnlyInResponse: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -686,7 +705,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -698,6 +717,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithAdditionalData outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -719,7 +739,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -730,6 +750,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithAdditionalData outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -751,7 +772,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -763,6 +784,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithAdditionalData outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -784,7 +806,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -796,6 +818,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithAdditionalData outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -817,7 +840,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -829,6 +852,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithAdditionalData outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -850,7 +874,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -862,6 +886,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithAdditionalData outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -883,7 +908,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -895,6 +920,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithSharableAttributes outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -916,7 +942,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -927,6 +953,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithSharableAttributes outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -948,7 +975,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -960,6 +987,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithSharableAttributes outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -981,7 +1009,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -993,6 +1021,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithSharableAttributes outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1014,7 +1043,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1026,6 +1055,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithSharableAttributes outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1047,7 +1077,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1059,6 +1089,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredentialWithSharableAttributes outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1080,7 +1111,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1092,6 +1123,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -1129,6 +1161,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -1167,6 +1200,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -1203,6 +1237,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -1240,6 +1275,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1260,7 +1296,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1272,6 +1308,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ @@ -1309,6 +1346,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1329,7 +1367,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1340,8 +1378,8 @@ RequestCredentials: Resident_RequestCredentials_Email_Channel_Pos: endPoint: /resident/v1/req/credential role: resident - checkErrorsOnlyInResponse: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1362,7 +1400,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForEmail", "maskedEmail": "$IGNORE$" @@ -1373,6 +1411,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -1393,7 +1432,7 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForPhone", "maskedMobile": "XXXXXX3210" @@ -1404,6 +1443,7 @@ RequestCredentials: endPoint: /resident/v1/req/credential role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error input: '{ diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs index 436bbc57722..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredentialResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$TIMESTAMP$", - "metadata": "$IGNORE$", - "response": { - "id": "{{id}}", - "requestId": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDoc.yml b/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDoc.yml index 478ab79fddb..73caf7b5abe 100644 --- a/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDoc.yml +++ b/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDoc.yml @@ -10,8 +10,7 @@ DeleteDoc: "docId": "$ID:UploadDocument_uin_all_Valid_Smoke_sid_docId$" }' output: '{ - "status": "SUCCESS", - "message": "Document deleted successfully" + "status": "SUCCESS" }' Resident_DeleteDoc_vid_all_Valid_Smoke: @@ -25,8 +24,7 @@ DeleteDoc: "docId": "$ID:UploadDocument_vid_all_Valid_Smoke_sid_docId$" }' output: '{ - "status": "SUCCESS", - "message": "Document deleted successfully" + "status": "SUCCESS" }' Resident_DeleteDoc_uin_Invalid_TransactionId_Neg: diff --git a/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDocResult.hbs b/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDocResult.hbs index 7553b230664..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDocResult.hbs +++ b/automationtests/src/main/resources/resident/DocumentController/DeleteDoc/DeleteDocResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.resident.document.delete", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocId.yml b/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocId.yml index 2f166ec3967..3a333484d52 100644 --- a/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocId.yml +++ b/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocId.yml @@ -2,6 +2,7 @@ GetDocByDocId: Resident_GetDocByDocId_uin_all_Valid_Smoke: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId outputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocIdResult @@ -16,6 +17,7 @@ GetDocByDocId: Resident_GetDocByDocId_vid_all_Valid_Smoke: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId outputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocIdResult @@ -30,6 +32,7 @@ GetDocByDocId: Resident_GetDocByDocId_uin_Invalid_TransactionId: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId outputTemplate: resident/error @@ -49,6 +52,7 @@ GetDocByDocId: Resident_GetDocByDocId_uin_Invalid_docId: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId outputTemplate: resident/error @@ -68,6 +72,7 @@ GetDocByDocId: Resident_GetDocByDocId_uin_Invalid_Token: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: partner + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId @@ -88,6 +93,7 @@ GetDocByDocId: Resident_GetDocByDocId_vid_Invalid_TransactionId: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId outputTemplate: resident/error @@ -107,6 +113,7 @@ GetDocByDocId: Resident_GetDocByDocId_vid_Invalid_docId: endPoint: /resident/v1/document/{docId}?transactionId={transactionId} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DocumentController/GetDocByDocId/GetDocByDocId outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocIdResult.hbs b/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocIdResult.hbs index 81d563e79ce..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocIdResult.hbs +++ b/automationtests/src/main/resources/resident/DocumentController/GetDocByDocId/GetDocByDocIdResult.hbs @@ -1,10 +1 @@ -{ - "id": "mosip.resident.document.get", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "document": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DocumentController/GetDocByTransId/GetDocByTransIdResult.hbs b/automationtests/src/main/resources/resident/DocumentController/GetDocByTransId/GetDocByTransIdResult.hbs index 8e9273f38e4..94786522a0e 100644 --- a/automationtests/src/main/resources/resident/DocumentController/GetDocByTransId/GetDocByTransIdResult.hbs +++ b/automationtests/src/main/resources/resident/DocumentController/GetDocByTransId/GetDocByTransIdResult.hbs @@ -1,17 +1,7 @@ { - "id": "mosip.resident.document.list", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": [ { - "transactionId": "{{transactionId}}", - "docId": "$IGNORE$", - "docName": "$IGNORE$", - "docCatCode": "$IGNORE$", - "docTypCode": "$IGNORE$", - "docFileFormat": "$IGNORE$" + "transactionId": "{{transactionId}}" } - ], - "errors": "$IGNORE$" + ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DocumentController/UploadDocument/UploadDocumentResult.hbs b/automationtests/src/main/resources/resident/DocumentController/UploadDocument/UploadDocumentResult.hbs index 0012795d49a..b927a084e48 100644 --- a/automationtests/src/main/resources/resident/DocumentController/UploadDocument/UploadDocumentResult.hbs +++ b/automationtests/src/main/resources/resident/DocumentController/UploadDocument/UploadDocumentResult.hbs @@ -1,8 +1,4 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "transactionId": "{{transactionId}}", "docId": "{{docId}}", @@ -10,6 +6,5 @@ "docCatCode": "{{docCatCode}}", "docTypCode": "{{docTypCode}}", "docFileFormat": "{{docFileFormat}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCen.yml b/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCen.yml index 2db4103e214..dc10f437404 100644 --- a/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCen.yml +++ b/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCen.yml @@ -2,6 +2,7 @@ DownloadNearestRegCen: Resident_DownloadNearestRegCen_allValid_smoke: endPoint: /resident/v1/download/nearestRegistrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCen outputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCenResult @@ -18,6 +19,7 @@ DownloadNearestRegCen: Resident_DownloadNearestRegCen_Invalid_Langcode_Neg: endPoint: /resident/v1/download/nearestRegistrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCen outputTemplate: resident/error @@ -34,6 +36,7 @@ DownloadNearestRegCen: Resident_DownloadNearestRegCen_Invalid_Latitude_Neg: endPoint: /resident/v1/download/nearestRegistrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCen outputTemplate: resident/error @@ -50,6 +53,7 @@ DownloadNearestRegCen: Resident_DownloadNearestRegCen_Invalid_Proximitydistance_Neg: endPoint: /resident/v1/download/nearestRegistrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCen outputTemplate: resident/error @@ -66,6 +70,7 @@ DownloadNearestRegCen: Resident_DownloadNearestRegCen_Invalid_Longitude_Neg: endPoint: /resident/v1/download/nearestRegistrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCen outputTemplate: resident/error @@ -82,6 +87,7 @@ DownloadNearestRegCen: Resident_DownloadNearestRegCen_Invalid_All_Inputs_Neg: endPoint: /resident/v1/download/nearestRegistrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadNearestRegCen/DownloadNearestRegCen outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCenResult.hbs b/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCenResult.hbs index 5c170b483c1..91ad89c2350 100644 --- a/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCenResult.hbs +++ b/automationtests/src/main/resources/resident/DownloadNearestRegCen/DownloadNearestRegCenResult.hbs @@ -1,13 +1,4 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - - }, - "errors": $IGNORE$ -} +{} diff --git a/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetails.yml b/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetails.yml index 6f91757183e..5ebf1f0c3a8 100644 --- a/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetails.yml +++ b/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetails.yml @@ -2,6 +2,7 @@ DownloadRegCenterDetails: Resident_DownloadRegCenterDetails_all_Valid_Smoke: endPoint: /resident/v1/download/registrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadRegCenterDetails/DownloadRegCenterDetails outputTemplate: resident/DownloadRegCenterDetails/DownloadRegCenterDetailsResult @@ -17,6 +18,7 @@ DownloadRegCenterDetails: Resident_DownloadRegCenterDetails_Invalid_Langcode_Neg: endPoint: /resident/v1/download/registrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadRegCenterDetails/DownloadRegCenterDetails outputTemplate: resident/error @@ -32,6 +34,7 @@ DownloadRegCenterDetails: Resident_DownloadRegCenterDetails_Invalid_Hierarchylevel_Neg: endPoint: /resident/v1/download/registrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadRegCenterDetails/DownloadRegCenterDetails outputTemplate: resident/error @@ -47,6 +50,7 @@ DownloadRegCenterDetails: Resident_DownloadRegCenterDetails_Invalid_Name_Neg: endPoint: /resident/v1/download/registrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadRegCenterDetails/DownloadRegCenterDetails outputTemplate: resident/error @@ -62,6 +66,7 @@ DownloadRegCenterDetails: Resident_DownloadRegCenterDetails_Invalid_All_Input_Neg: endPoint: /resident/v1/download/registrationcenters role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadRegCenterDetails/DownloadRegCenterDetails outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetailsResult.hbs b/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetailsResult.hbs index bdb0d0253f3..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetailsResult.hbs +++ b/automationtests/src/main/resources/resident/DownloadRegCenterDetails/DownloadRegCenterDetailsResult.hbs @@ -1,10 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistory.yml b/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistory.yml index 396427fa004..98f15c532d9 100644 --- a/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistory.yml +++ b/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistory.yml @@ -2,6 +2,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_all_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -24,6 +25,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_Invalid_User_Neg: endPoint: /resident/v1/download/service-history role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -46,6 +48,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_Missing_LangCode_Neg: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -68,6 +71,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_FromDate_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -90,6 +94,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_ToDate_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -112,6 +117,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_PageStart_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -134,6 +140,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_ServiceType_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -156,6 +163,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_SortType_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -178,6 +186,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_uin_StatusFilter_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -200,6 +209,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_all_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -222,6 +232,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_Missing_LangCode_Neg: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -244,6 +255,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_FromDate_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -266,6 +278,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_ToDate_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -288,6 +301,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_PageStart_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -310,6 +324,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_ServiceType_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -332,6 +347,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_SortType_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult @@ -354,6 +370,7 @@ DownloadServiceHistory: Resident_DownloadServiceHistory_vid_StatusFilter_Valid_Smoke: endPoint: /resident/v1/download/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadServiceHistory/DownloadServiceHistory outputTemplate: resident/DownloadServiceHistory/DownloadServiceHistoryResult diff --git a/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistoryResult.hbs b/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistoryResult.hbs index 9c06433d4f4..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistoryResult.hbs +++ b/automationtests/src/main/resources/resident/DownloadServiceHistory/DownloadServiceHistoryResult.hbs @@ -1,18 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "mosip.resident.api.id.auth": "mosip.identity.auth.internal", - "mosip.resident.api.version.otp.request": "1.0", - "resident.datetime.pattern": "$IGNORE$", - "mosip.mandatory-languages": "$IGNORE$", - "mosip.resident.api.version.auth": "1.0", - "mosip.optional-languages": "$IGNORE$", - "mosip.resident.api.id.otp.request": "mosip.identity.otp.internal", - "mosip.utc-datetime-pattern": "$IGNORE$", - "mosip.iam.adapter.clientid": "mosip-resident-client" - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocs.yml b/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocs.yml index 7e39cf9a616..00f57149958 100644 --- a/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocs.yml +++ b/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocs.yml @@ -2,6 +2,7 @@ DownloadSupportingDocs: Resident_DownloadSupportingDocs_all_Valid_smoke: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocs outputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocsResult @@ -14,6 +15,7 @@ DownloadSupportingDocs: Resident_DownloadSupportingDocs_Valid_smoke: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocs outputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocsResult @@ -27,6 +29,7 @@ DownloadSupportingDocs: Resident_DownloadSupportingDocs_Empty_Lang_Neg: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocs outputTemplate: resident/error @@ -40,6 +43,7 @@ DownloadSupportingDocs: Resident_DownloadSupportingDocs_Invalid_token_Neg: endPoint: /resident/v1/download/supporting-documents role: invalid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocs outputTemplate: resident/error @@ -52,6 +56,7 @@ DownloadSupportingDocs: Resident_DownloadSupportingDocs_Invalid_lang_Neg: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocs outputTemplate: resident/error @@ -64,6 +69,7 @@ DownloadSupportingDocs: Resident_DownloadSupportingDocs_Absent_langCode_Neg: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadSupportingDocs/DownloadSupportingDocs outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocsResult.hbs b/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocsResult.hbs index 0d6cdecce61..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocsResult.hbs +++ b/automationtests/src/main/resources/resident/DownloadSupportingDocs/DownloadSupportingDocsResult.hbs @@ -1,10 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - - }, - "errors": $IGNORE$ -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCard.yml b/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCard.yml index ef4faa7ab9e..520cfbf40c4 100644 --- a/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCard.yml +++ b/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCard.yml @@ -2,6 +2,7 @@ DownloadUinCard: Resident_DownloadUinCard_all_Valid_Smoke: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post auditLogCheck: true inputTemplate: resident/DownloadUinCard/DownloadUinCard @@ -33,6 +34,7 @@ DownloadUinCard: Resident_DownloadUinCard_Invalid_TransactionID_Neg: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/DownloadUinCard/DownloadUinCard outputTemplate: resident/DownloadUinCard/DownloadUinCardResult @@ -67,6 +69,7 @@ DownloadUinCard: Resident_DownloadUinCard_Empty_TransactionID_Neg: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/DownloadUinCard/DownloadUinCard outputTemplate: resident/DownloadUinCard/DownloadUinCardResult @@ -101,6 +104,7 @@ DownloadUinCard: Resident_DownloadUinCard_Invalid_Otp_Neg: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/DownloadUinCard/DownloadUinCard outputTemplate: resident/DownloadUinCard/DownloadUinCardResult @@ -135,6 +139,7 @@ DownloadUinCard: Resident_DownloadUinCard_Empty_Otp_Neg: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/DownloadUinCard/DownloadUinCard outputTemplate: resident/DownloadUinCard/DownloadUinCardResult @@ -169,6 +174,7 @@ DownloadUinCard: Resident_DownloadUinCard_Invalid_IndividualID_Neg: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/DownloadUinCard/DownloadUinCard outputTemplate: resident/DownloadUinCard/DownloadUinCardResult @@ -203,6 +209,7 @@ DownloadUinCard: Resident_DownloadUinCard_Empty_IndividualID_Neg: endPoint: /resident/v1/download-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/DownloadUinCard/DownloadUinCard outputTemplate: resident/DownloadUinCard/DownloadUinCardResult diff --git a/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCardResult.hbs b/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCardResult.hbs index d3bd65653fd..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCardResult.hbs +++ b/automationtests/src/main/resources/resident/DownloadUinCard/DownloadUinCardResult.hbs @@ -1,8 +1 @@ -{ - "id": null, - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventId.yml b/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventId.yml index 9a3a230cf5a..ab343d5bd7a 100644 --- a/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventId.yml +++ b/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventId.yml @@ -2,6 +2,7 @@ DownloadUinCardByEventId: Resident_DownloadUinCardByEventId_uin_all_Valid_Smoke: endPoint: /resident/v1/download-card/event/{eventId} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get auditLogCheck: true inputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventId @@ -16,6 +17,7 @@ DownloadUinCardByEventId: Resident_DownloadUinCardByEventId_vid_all_Valid_Smoke: endPoint: /resident/v1/download-card/event/{eventId} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventId outputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventIdResult @@ -29,6 +31,7 @@ DownloadUinCardByEventId: Resident_DownloadUinCardByEventId_uin_Invalid_EventId_Neg: endPoint: /resident/v1/download-card/event/{eventId} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventId outputTemplate: resident/error @@ -42,6 +45,7 @@ DownloadUinCardByEventId: Resident_DownloadUinCardByEventId_vid_Invalid_EventId_Neg: endPoint: /resident/v1/download-card/event/{eventId} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventId outputTemplate: resident/error @@ -59,6 +63,7 @@ DownloadUinCardByEventId: endPoint: /resident/v1/download-card/event/{eventId} role: validityCheckRequired: true + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventId outputTemplate: resident/error @@ -78,6 +83,7 @@ DownloadUinCardByEventId: Resident_DownloadUinCardByEventId_uin_Diff_User_Neg: endPoint: /resident/v1/download-card/event/{eventId} role: resident + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: get inputTemplate: resident/DownloadUinCardByEventId/DownloadUinCardByEventId diff --git a/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventIdResult.hbs b/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventIdResult.hbs index 761460ba1d3..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventIdResult.hbs +++ b/automationtests/src/main/resources/resident/DownloadUinCardByEventId/DownloadUinCardByEventIdResult.hbs @@ -1,10 +1 @@ -{ - "id": "mosip.resident.download.card.eventid", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GenerateToken/GenerateTokenResult.hbs b/automationtests/src/main/resources/resident/GenerateToken/GenerateTokenResult.hbs index c61b3a64f21..c323e20a77e 100644 --- a/automationtests/src/main/resources/resident/GenerateToken/GenerateTokenResult.hbs +++ b/automationtests/src/main/resources/resident/GenerateToken/GenerateTokenResult.hbs @@ -1,6 +1,3 @@ { - "id_token": "$IGNORE$", - "access_token": "$IGNORE$", - "token_type": "{{token_type}}", - "expires_in": "$IGNORE$" + "token_type": "{{token_type}}" } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index 909fa428c95..0a230f7ce91 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -3,6 +3,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -24,8 +25,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -37,6 +36,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -58,8 +58,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -71,6 +69,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -92,8 +91,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -105,6 +102,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -126,8 +124,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -139,6 +135,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -160,8 +157,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -173,6 +168,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -194,8 +190,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -206,6 +200,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -227,8 +222,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -240,6 +233,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -261,8 +255,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -274,6 +266,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -295,8 +288,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -308,6 +299,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -329,8 +321,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -342,6 +332,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -363,8 +354,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -376,6 +365,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -413,6 +403,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -451,6 +442,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -488,6 +480,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -525,6 +518,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -564,6 +558,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -601,6 +596,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -638,6 +634,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -676,6 +673,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -714,6 +712,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -751,6 +750,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -788,6 +788,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -825,6 +826,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -862,6 +864,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -900,6 +903,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -938,6 +942,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -976,6 +981,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1014,6 +1020,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1052,6 +1059,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1090,6 +1098,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1128,6 +1137,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1166,6 +1176,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1204,6 +1215,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1242,6 +1254,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1263,8 +1276,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1276,6 +1287,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1297,8 +1309,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1310,6 +1320,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1331,8 +1342,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1340,12 +1349,13 @@ GenerateVID: } }' - Resident_Generate_Perpetual_VID_Using_Perpetual_VID_Neg: + Resident_Generate_Perpetual_VID_Using_Perpetual_VID_Pos: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID - outputTemplate: resident/error + outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ "transactionID": "$TRANSACTIONID$", "individualId": "$ID:Generate_Perpetual_VID_Using_Temp_VID_Smoke_sid_vid$", @@ -1365,12 +1375,6 @@ GenerateVID: } }' output: '{ - "errors": [ - { - "errorCode": "RES-SER-29", - "message": "$IGNORE$" - } - ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1382,6 +1386,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1403,8 +1408,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1416,6 +1419,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1437,8 +1441,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1450,6 +1452,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1488,6 +1491,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1526,6 +1530,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1564,6 +1569,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1602,6 +1608,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1640,6 +1647,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1678,6 +1686,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1716,6 +1725,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1737,8 +1747,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1750,6 +1758,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1771,8 +1780,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1784,6 +1791,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1805,8 +1813,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForPhone" @@ -1816,8 +1822,8 @@ GenerateVID: Resident_Generate_Perpetual_VID_Email_Valid_Smoke_sid: endPoint: /resident/v1/vid role: resident - checkErrorsOnlyInResponse: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1839,8 +1845,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"resident/SendOTP/createSendOTPResultForEmail", "maskedEmail": "$IGNORE$" @@ -1851,6 +1855,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/error input: '{ @@ -1892,6 +1897,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1913,8 +1919,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1926,6 +1930,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1947,8 +1952,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1960,6 +1963,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -1981,8 +1985,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -1994,6 +1996,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2015,8 +2018,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2028,6 +2029,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2049,8 +2051,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2062,6 +2062,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2083,8 +2084,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2096,6 +2095,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2117,8 +2117,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2129,6 +2127,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2150,8 +2149,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2162,6 +2159,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2183,8 +2181,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2195,6 +2191,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2216,8 +2213,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2228,6 +2223,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2249,8 +2245,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2261,6 +2255,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2282,8 +2277,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2295,6 +2288,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2316,8 +2310,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2329,6 +2321,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2350,8 +2343,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2363,6 +2354,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2384,8 +2376,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2397,6 +2387,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2418,8 +2409,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2430,6 +2419,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2451,8 +2441,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2463,6 +2451,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2484,8 +2473,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2496,6 +2483,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2517,8 +2505,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2529,6 +2515,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2550,8 +2537,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2562,6 +2547,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2583,8 +2569,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -2596,6 +2580,7 @@ GenerateVID: endPoint: /resident/v1/vid role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult input: '{ @@ -2617,8 +2602,6 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml index 47a32b95ecb..df29823f767 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml @@ -13,8 +13,6 @@ GenerateVIDNew: "vidType": "Temporary" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "maskedPhone": "******3210", "maskedEmail": "res***************@gmail.com" }' @@ -33,8 +31,6 @@ GenerateVIDNew: "vidType": "Temporary" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "maskedPhone": "******3210", "maskedEmail": "res***************@gmail.com" }' @@ -53,8 +49,6 @@ GenerateVIDNew: "vidType": "Onetimeuse" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "maskedPhone": "******3210", "maskedEmail": "res***************@gmail.com" }' @@ -73,8 +67,6 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact phone number", "maskedPhone": "******3210", "maskedEmail": "$IGNORE$" }' @@ -93,8 +85,6 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided email ", "maskedPhone": "$IGNORE$", "maskedEmail": "res***************@gmail.com" }' @@ -113,8 +103,6 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "maskedPhone": "******3210", "maskedEmail": "res***************@gmail.com" }' @@ -333,8 +321,6 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "maskedPhone": "******3210", "maskedEmail": "res***************@gmail.com" }' @@ -375,8 +361,6 @@ GenerateVIDNew: "vidType": "Onetimeuse" }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "maskedPhone": "******3210", "maskedEmail": "res***************@gmail.com" }' diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs index f5b7072998d..1ec37c80830 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs @@ -1,12 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { "vid": "{{vid}}", - "message": "{{message}}", - "maskedPhone": "{{maskedPhone}}", - "maskedEmail": "$IGNORE$" - }, - "errors": [] + "maskedPhone": "{{maskedPhone}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs index 52cd68d71a0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs @@ -1,10 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "vid": "$IGNORE$", - "message": "{{message}}" - }, - "errors": [] -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml b/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml index ac799fd354a..901c0f59c6f 100644 --- a/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml +++ b/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml @@ -2,6 +2,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_uin_1_Valid_Smoke: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult @@ -16,6 +17,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_uin_2_Valid_Smoke: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult @@ -30,6 +32,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_uin_3_Valid_Smoke: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult @@ -44,6 +47,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_uin_Invalid_Langcode: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/error @@ -63,6 +67,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_uin_Invalid_Templatetypecode: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/error @@ -82,6 +87,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_Invalid_Token: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: invalid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/error @@ -101,6 +107,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_vid_1_Valid_Smoke: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult @@ -115,6 +122,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_vid_2_Valid_Smoke: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult @@ -129,6 +137,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_vid_3_Valid_Smoke: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult @@ -143,6 +152,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_vid_Invalid_Langcode: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/error @@ -162,6 +172,7 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_vid_Invalid_Templatetypecode: endPoint: /resident/v1/auth-proxy/masterdata/templates/{langcode}/{templatetypecode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult.hbs b/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult.hbs index 38b95b914e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult.hbs +++ b/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCodeResult.hbs @@ -1,9 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetAuthLockStatus/GetAuthLockStatus.yml b/automationtests/src/main/resources/resident/GetAuthLockStatus/GetAuthLockStatus.yml index ef87b719ab1..110a0cc1af7 100644 --- a/automationtests/src/main/resources/resident/GetAuthLockStatus/GetAuthLockStatus.yml +++ b/automationtests/src/main/resources/resident/GetAuthLockStatus/GetAuthLockStatus.yml @@ -2,6 +2,7 @@ residentNewVid: Resident_GetAuthLockStatus_uin_all_Valid_Smoke: endPoint: /resident/v1/auth-lock-status role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAuthLockStatus/getAuthLockStatus outputTemplate: resident/GetAuthLockStatus/getAuthLockStatusResult @@ -13,6 +14,7 @@ residentNewVid: Resident_GetAuthLockStatus_Invalid_Token_Neg: endPoint: /resident/v1/auth-lock-status role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAuthLockStatus/getAuthLockStatus outputTemplate: resident/error @@ -30,6 +32,7 @@ residentNewVid: Resident_GetAuthLockStatus_Vid_all_Valid_Smoke: endPoint: /resident/v1/auth-lock-status role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetAuthLockStatus/getAuthLockStatus outputTemplate: resident/GetAuthLockStatus/getAuthLockStatusResult diff --git a/automationtests/src/main/resources/resident/GetAuthLockStatus/getAuthLockStatusResult.hbs b/automationtests/src/main/resources/resident/GetAuthLockStatus/getAuthLockStatusResult.hbs index 46896f4afd3..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetAuthLockStatus/getAuthLockStatusResult.hbs +++ b/automationtests/src/main/resources/resident/GetAuthLockStatus/getAuthLockStatusResult.hbs @@ -1,9 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusNegativeResult.hbs b/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusNegativeResult.hbs index 8e235de97bf..100bd9efbae 100644 --- a/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusNegativeResult.hbs +++ b/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusNegativeResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.channel.verification.status", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "metadata": null, "response": { "verificationStatus": false - }, - "errors": null + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusResult.hbs b/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusResult.hbs index 996835cc4d6..77d27060e7d 100644 --- a/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusResult.hbs +++ b/automationtests/src/main/resources/resident/GetChannelVerificationStatus/getChannelVerificationStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.channel.verification.status", - "version": "1.0", - "responseTime": "$IGNORE$", - "metadata": null, "response": { "verificationStatus": "{{verificationStatus}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatus.yml b/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatus.yml index f6bd3fbc2c7..8b78d724151 100644 --- a/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatus.yml +++ b/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatus.yml @@ -2,6 +2,7 @@ GetCheckEventIdStatus: Resident_GetCheckEventIdStatus_uin_all_Valid_Smoke: endPoint: /resident/v1/events/{eventId}?langCode={langCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatus outputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatusResult @@ -16,6 +17,7 @@ GetCheckEventIdStatus: Resident_GetCheckEventIdStatus_vid_all_Valid_Smoke: endPoint: /resident/v1/events/{eventId}?langCode={langCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatus outputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatusResult @@ -30,6 +32,7 @@ GetCheckEventIdStatus: Resident_GetCheckEventIdStatus_uin_Invalid_eventId_Neg: endPoint: /resident/v1/events/{eventId}?langCode={langCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatus outputTemplate: resident/error @@ -49,6 +52,7 @@ GetCheckEventIdStatus: Resident_GetCheckEventIdStatus_vid_Invalid_eventId_Neg: endPoint: /resident/v1/events/{eventId}?langCode={langCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatus outputTemplate: resident/error @@ -68,6 +72,7 @@ GetCheckEventIdStatus: Resident_GetCheckEventIdStatus_uin_Invalid_LangCode_Neg: endPoint: /resident/v1/events/{eventId}?langCode={langCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatus outputTemplate: resident/error @@ -87,6 +92,7 @@ GetCheckEventIdStatus: Resident_GetCheckEventIdStatus_vid_Invalid_LangCode_Neg: endPoint: /resident/v1/events/{eventId}?langCode={langCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCheckEventIdStatus/GetCheckEventIdStatus outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatusResult.hbs b/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatusResult.hbs index 8c281b3ea41..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatusResult.hbs +++ b/automationtests/src/main/resources/resident/GetCheckEventIdStatus/GetCheckEventIdStatusResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.resident.event.status", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCentersResult.hbs b/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCentersResult.hbs index 5d77e036869..91ad89c2350 100644 --- a/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCentersResult.hbs +++ b/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCentersResult.hbs @@ -1,39 +1,4 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "registrationCenters": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "34.52117", - "longitude": "-6.453275", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" - } - ] - }, - "errors": $IGNORE$ -} +{} diff --git a/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypesResult.hbs b/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypesResult.hbs index 394dc56d52d..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypesResult.hbs +++ b/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypesResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCode.yml b/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCode.yml index af8e39337f4..eec2246408a 100644 --- a/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCode.yml +++ b/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCode.yml @@ -2,6 +2,7 @@ GetGenderCode: Resident_GetGenderCode_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/gendercode/{gendertype}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetGenderCode/GetGenderCode outputTemplate: resident/GetGenderCode/GetGenderCodeResult @@ -15,6 +16,7 @@ GetGenderCode: Resident_GetGenderCode1_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/gendercode/{gendertype}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetGenderCode/GetGenderCode outputTemplate: resident/GetGenderCode/GetGenderCodeResult @@ -28,6 +30,7 @@ GetGenderCode: Resident_GetGenderCode2_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/gendercode/{gendertype}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetGenderCode/GetGenderCode outputTemplate: resident/GetGenderCode/GetGenderCodeResult @@ -41,6 +44,7 @@ GetGenderCode: Resident_GetGenderCode_Invalid_GenderType_Neg: endPoint: /resident/v1/proxy/masterdata/gendercode/{gendertype}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetGenderCode/GetGenderCode outputTemplate: resident/error @@ -55,6 +59,7 @@ GetGenderCode: Resident_GetGenderCode_Invalid_langCode_Neg: endPoint: /resident/v1/proxy/masterdata/gendercode/{gendertype}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetGenderCode/GetGenderCode outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCodeResult.hbs b/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCodeResult.hbs index 394dc56d52d..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCodeResult.hbs +++ b/automationtests/src/main/resources/resident/GetGenderCode/GetGenderCodeResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml b/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml index bfed28d4da5..f6ae77decff 100644 --- a/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml +++ b/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml @@ -2,6 +2,7 @@ GetIdentityMapping: Resident_GetIdentityMapping_all_Valid_Smoke: endPoint: /resident/v1/proxy/config/identity-mapping role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetIdentityMapping/getIdentityMapping outputTemplate: resident/GetIdentityMapping/getIdentityMappingResult diff --git a/automationtests/src/main/resources/resident/GetIdentityMapping/getIdentityMappingResult.hbs b/automationtests/src/main/resources/resident/GetIdentityMapping/getIdentityMappingResult.hbs index 60cc578a209..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetIdentityMapping/getIdentityMappingResult.hbs +++ b/automationtests/src/main/resources/resident/GetIdentityMapping/getIdentityMappingResult.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": {}, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml b/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml index 55c26b68b9d..3e053a6fb74 100644 --- a/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml +++ b/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml @@ -2,6 +2,7 @@ GetImmediateChildrenByLocCodeAndLangCode: Resident_GetImmediateChildrenByLocCodeAndLangCode_allValid_smoke: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCode outputTemplate: resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCodeResult @@ -10,20 +11,12 @@ GetImmediateChildrenByLocCodeAndLangCode: "langCode":"$1STLANG$" }' output: '{ - "locations": [{ - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "{{parentLocCode}}", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }] }' Resident_GetImmediateChildrenByLocCodeAndLangCode_Invalid_locationCode: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCode outputTemplate: resident/error @@ -43,6 +36,7 @@ GetImmediateChildrenByLocCodeAndLangCode: Resident_GetImmediateChildrenByLocCodeAndLangCode_Invalid_langCode: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCode outputTemplate: resident/error @@ -62,6 +56,7 @@ GetImmediateChildrenByLocCodeAndLangCode: Resident_GetImmediateChildrenByLocCodeAndLangCode_StatusCode_Empty_locationCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCode outputTemplate: resident/error @@ -74,6 +69,7 @@ GetImmediateChildrenByLocCodeAndLangCode: Resident_GetImmediateChildrenByLocCodeAndLangCode_StatusCode_Empty_langCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCode outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCodeResult.hbs b/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCodeResult.hbs index 88cc1d0e054..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCodeResult.hbs +++ b/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/getImmediateChildrenByLocCodeAndLangCodeResult.hbs @@ -1,83 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "locations": [ - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetInputAttributeValues/GetInputAttributeValues.yml b/automationtests/src/main/resources/resident/GetInputAttributeValues/GetInputAttributeValues.yml index 4827ba148b6..34d49a1630e 100644 --- a/automationtests/src/main/resources/resident/GetInputAttributeValues/GetInputAttributeValues.yml +++ b/automationtests/src/main/resources/resident/GetInputAttributeValues/GetInputAttributeValues.yml @@ -2,6 +2,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues1_UIN_all_Valid_Smoke: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get auditLogCheck: true inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues @@ -15,6 +16,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues2_UIN_all_Valid_Smoke: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues outputTemplate: resident/GetInputAttributeValues/getInputAttributeValuesResult @@ -27,6 +29,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues3_UIN_all_Valid_Smoke: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues outputTemplate: resident/GetInputAttributeValues/getInputAttributeValuesResult @@ -39,6 +42,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues_UIN_Invalid_SchemaType_Neg: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues outputTemplate: resident/error @@ -57,6 +61,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues1_Vid_all_Valid_Smoke: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues outputTemplate: resident/GetInputAttributeValues/getInputAttributeValuesResult @@ -69,6 +74,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues2_Vid_all_Valid_Smoke: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues outputTemplate: resident/GetInputAttributeValues/getInputAttributeValuesResult @@ -81,6 +87,7 @@ GetInputAttributeValues: Resident_GetInputAttributeValues3_Vid_all_Valid_Smoke: endPoint: /resident/v1/identity/info/type/{schemaType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetInputAttributeValues/getInputAttributeValues outputTemplate: resident/GetInputAttributeValues/getInputAttributeValuesResult diff --git a/automationtests/src/main/resources/resident/GetInputAttributeValues/getInputAttributeValuesResult.hbs b/automationtests/src/main/resources/resident/GetInputAttributeValues/getInputAttributeValuesResult.hbs index b24c3009e87..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetInputAttributeValues/getInputAttributeValuesResult.hbs +++ b/automationtests/src/main/resources/resident/GetInputAttributeValues/getInputAttributeValuesResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.resident.identity.info", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotification.yml b/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotification.yml index 92890263528..b9d797bd749 100644 --- a/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotification.yml +++ b/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotification.yml @@ -2,6 +2,7 @@ GetLastClickNotification: Resident_GetLastClickNotification_uin_all_Valid_Smoke: endPoint: /resident/v1/bell/notification-click role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLastClickNotification/GetLastClickNotification outputTemplate: resident/GetLastClickNotification/GetLastClickNotificationResult @@ -14,6 +15,7 @@ GetLastClickNotification: Resident_GetLastClickNotification_vid_all_Valid_Smoke: endPoint: /resident/v1/bell/notification-click role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLastClickNotification/GetLastClickNotification outputTemplate: resident/GetLastClickNotification/GetLastClickNotificationResult @@ -26,6 +28,7 @@ GetLastClickNotification: Resident_GetLastClickNotification_Invalid_Token: endPoint: /resident/v1/bell/notification-click role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLastClickNotification/GetLastClickNotification outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotificationResult.hbs b/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotificationResult.hbs index 07cdb010c61..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotificationResult.hbs +++ b/automationtests/src/main/resources/resident/GetLastClickNotification/GetLastClickNotificationResult.hbs @@ -1,6 +1 @@ -{ - "id": "mosip.resident.event.status", - "version": "1.0", - "responsetime": "$IGNORE$", - "response": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetLatestIdSchema/GetLatestIdSchema.yml b/automationtests/src/main/resources/resident/GetLatestIdSchema/GetLatestIdSchema.yml index e3ae749ea10..66f56cb2a14 100644 --- a/automationtests/src/main/resources/resident/GetLatestIdSchema/GetLatestIdSchema.yml +++ b/automationtests/src/main/resources/resident/GetLatestIdSchema/GetLatestIdSchema.yml @@ -2,6 +2,7 @@ GetLatestIdSchema: Resident_GetLatestIdSchema_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/idschema/latest?schemaVersion={schemaVersion}&domain={domain}&type={type} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLatestIdSchema/getLatestIdSchema outputTemplate: resident/GetLatestIdSchema/getLatestIdSchemaResult @@ -16,6 +17,7 @@ GetLatestIdSchema: Resident_GetLatestIdSchema_Invalid_Schema_Version: endPoint: /resident/v1/proxy/masterdata/idschema/latest?schemaVersion={schemaVersion}&domain={domain}&type={type} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLatestIdSchema/getLatestIdSchema outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetLatestIdSchema/getLatestIdSchemaResult.hbs b/automationtests/src/main/resources/resident/GetLatestIdSchema/getLatestIdSchemaResult.hbs index 7f16d0ef459..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetLatestIdSchema/getLatestIdSchemaResult.hbs +++ b/automationtests/src/main/resources/resident/GetLatestIdSchema/getLatestIdSchemaResult.hbs @@ -1,35 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "id": "$IGNORE$", - "inputRequired": "$IGNORE$", - "type": "$IGNORE$", - "minimum": "$IGNORE$", - "maximum": "$IGNORE$", - "description": "$IGNORE$", - "label": "$IGNORE$", - "controlType": "$IGNORE$", - "fieldType": "$IGNORE$", - "format": "$IGNORE$", - "validators": "$IGNORE$", - "fieldCategory": "$IGNORE$", - "alignmentGroup": "$IGNORE$", - "visible": "$IGNORE$", - "contactType": "$IGNORE$", - "group": "$IGNORE$", - "groupLabel": "$IGNORE$", - "changeAction": "$IGNORE$", - "transliterate": "$IGNORE$", - "templateName": "$IGNORE$", - "fieldLayout": "$IGNORE$", - "locationHierarchy": "$IGNORE$", - "required": "$IGNORE$", - "bioAttributes": "$IGNORE$", - "requiredOn": "$IGNORE$", - "subType": "$IGNORE$" - }, - "error": "$IGNORE$" - } \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml b/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml index 6641616ade6..02a3d3eb27a 100644 --- a/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml +++ b/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml @@ -2,6 +2,7 @@ GetLocationDetailsByLocCodeAndLangCode: Resident_GetLocationDetailsByLocCodeAndLangCode_allValid_smoke: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCode outputTemplate: resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCodeResult @@ -10,31 +11,13 @@ GetLocationDetailsByLocCodeAndLangCode: "loccode": "14022" }' output: '{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$" - }, - "errors": null + }' Resident_GetLocationDetailsByLocCodeAndLangCode_Invalid_LangCode: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCode outputTemplate: resident/error @@ -54,6 +37,7 @@ GetLocationDetailsByLocCodeAndLangCode: Resident_GetLocationDetailsByLocCodeAndLangCode_Invalid_LocationCode: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCode outputTemplate: resident/error @@ -73,6 +57,7 @@ GetLocationDetailsByLocCodeAndLangCode: Resident_GetLocationDetailsByLocCodeAndLangCode_StatusCode_Empty_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCode outputTemplate: resident/error @@ -85,6 +70,7 @@ GetLocationDetailsByLocCodeAndLangCode: Resident_GetLocationDetailsByLocCodeAndLangCode_StatusCode_Empty_LocationCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCode outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCodeResult.hbs b/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCodeResult.hbs index c3633217dea..91ad89c2350 100644 --- a/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCodeResult.hbs +++ b/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/getLocationDetailsByLocCodeAndLangCodeResult.hbs @@ -1,25 +1,4 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "code": "$IGNORE$", - "name": "$IGNORE$", - "hierarchyLevel": "$IGNORE$", - "hierarchyName": "$IGNORE$", - "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$" - }, - "errors": "$IGNORE$" -} +{} diff --git a/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml b/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml index c1646a1e358..9949fedbae6 100644 --- a/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml +++ b/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml @@ -2,6 +2,7 @@ GetLocationHierarchyByLanguageCode: Resident_GetLocationHierarchyByLanguageCode_All_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/locationHierarchyLevels/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCode outputTemplate: resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCodeResult @@ -9,16 +10,13 @@ GetLocationHierarchyByLanguageCode: "langCode":"$1STLANG$" }' output: '{ - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" }' Resident_GetLocationHierarchyByLanguageCode_InValid_LangCode: endPoint: /resident/v1/proxy/masterdata/locationHierarchyLevels/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCode outputTemplate: resident/error @@ -37,6 +35,7 @@ GetLocationHierarchyByLanguageCode: Resident_GetLocationHierarchyByLanguageCode_StatusCode_Empty_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/locationHierarchyLevels/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCode outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCodeResult.hbs b/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCodeResult.hbs index f36cb396288..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCodeResult.hbs +++ b/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/getLocationHierarchyByLangCodeResult.hbs @@ -1,47 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "locationHierarchyLevels": [ - { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - }, - { - "hierarchyLevel": "$IGNORE$", - "hierarchyLevelName": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml b/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml index 10cf32e9a9e..1134e8813d4 100644 --- a/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml +++ b/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml @@ -2,6 +2,7 @@ GetNotifications: Resident_GetNotifications_vid_all_Valid_Smoke: endPoint: /resident/v1/notifications/{langCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/GetNotifications/GetNotificationsResult @@ -17,6 +18,7 @@ GetNotifications: Resident_GetNotifications_vid_pageFetch_all_Valid_Smoke: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/GetNotifications/GetNotificationsResult @@ -32,6 +34,7 @@ GetNotifications: Resident_GetNotifications_vid_pageStart_all_Valid_Smoke: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/GetNotifications/GetNotificationsResult @@ -47,6 +50,7 @@ GetNotifications: Resident_GetNotifications_Invalid_pageStart_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -67,6 +71,7 @@ GetNotifications: Resident_GetNotifications_vid_Invalid_Token_Neg: endPoint: /resident/v1/notifications/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -87,6 +92,7 @@ GetNotifications: Resident_GetNotifications_vid_1_Invalid_PageNo_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -108,6 +114,7 @@ GetNotifications: Resident_GetNotifications_vid_all_InValid_langcode_Neg: endPoint: /resident/v1/notifications/{langCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -128,6 +135,7 @@ GetNotifications: Resident_GetNotifications_vid_SpaceVal_langcode_Neg: endPoint: /resident/v1/notifications/{langCode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -148,6 +156,7 @@ GetNotifications: Resident_GetNotifications_vid_Neg_Value_PageStart_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -168,6 +177,7 @@ GetNotifications: Resident_GetNotifications_vid_Neg_Value_pageFetch_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -189,6 +199,7 @@ GetNotifications: Resident_GetNotifications_vid_StringVal_Invalid_pageFetch_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -209,6 +220,7 @@ GetNotifications: Resident_GetNotifications_vid_StringVal_Invalid_pageStart_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -229,6 +241,7 @@ GetNotifications: Resident_GetNotifications_uin_all_Valid_Smoke: endPoint: /resident/v1/notifications/{langCode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/GetNotifications/GetNotificationsResult @@ -244,6 +257,7 @@ GetNotifications: Resident_GetNotifications_uin_pageFetch_all_Valid_Smoke: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/GetNotifications/GetNotificationsResult @@ -259,6 +273,7 @@ GetNotifications: Resident_GetNotifications_uin_pageStart_all_Valid_Smoke: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/GetNotifications/GetNotificationsResult @@ -271,30 +286,25 @@ GetNotifications: }' - Resident_GetNotifications_uin_1_Invalid_PageNo_Neg: + Resident_GetNotifications_uin_1_Invalid_PageNo_Pos: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error input: '{ "langCode": "$1STLANG$", - "pageStart":"11", + "pageStart":"52", "pageFetch":"2" }' - output: '{ - "errors": [ - { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" - } - ] - + output: '{ }' Resident_GetNotifications_uin_all_InValid_langcode_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -315,6 +325,7 @@ GetNotifications: Resident_GetNotifications_uin_StatusCode_empty_langcode_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -328,6 +339,7 @@ GetNotifications: Resident_GetNotifications_uin_SpaceVal_langcode_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -348,6 +360,7 @@ GetNotifications: Resident_GetNotifications_uin_Neg_Value_PageStart_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error @@ -368,6 +381,7 @@ GetNotifications: Resident_GetNotifications_uin_Neg_Value_pageFetch_Neg: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetNotifications/GetNotificationsResult.hbs b/automationtests/src/main/resources/resident/GetNotifications/GetNotificationsResult.hbs index 8ac1d1a8f73..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetNotifications/GetNotificationsResult.hbs +++ b/automationtests/src/main/resources/resident/GetNotifications/GetNotificationsResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.resident.service.history.unread", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetOrderStatus/GetOrderStatusResult.hbs b/automationtests/src/main/resources/resident/GetOrderStatus/GetOrderStatusResult.hbs index c3b891a94d6..e0206aa400a 100644 --- a/automationtests/src/main/resources/resident/GetOrderStatus/GetOrderStatusResult.hbs +++ b/automationtests/src/main/resources/resident/GetOrderStatus/GetOrderStatusResult.hbs @@ -1,7 +1,5 @@ { - "responsetime": "$IGNORE$", "response": { - "transactionId": "{{transactionId}}", - "trackingId": "$IGNORE$" + "transactionId": "{{transactionId}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml b/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml index 0522189cb34..c8985b871a6 100644 --- a/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml +++ b/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml @@ -2,6 +2,7 @@ GetPartnersByPartnerType: Resident_GetPartnersByPartnerType_uin_all_Valid_Smoke: endPoint: /resident/v1/auth-proxy/partners?partnerType={partnerType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get auditLogCheck: true inputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerType @@ -15,6 +16,7 @@ GetPartnersByPartnerType: Resident_GetPartnersByPartnerType_uin_Empty_PartnerType_Valid_Smoke: endPoint: /resident/v1/auth-proxy/partners?partnerType={partnerType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerType outputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult @@ -27,6 +29,7 @@ GetPartnersByPartnerType: Resident_GetPartnersByPartnerType_Invalid_Token: endPoint: /resident/v1/auth-proxy/partners?partnerType={partnerType} role: residen + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerType outputTemplate: resident/error @@ -45,6 +48,7 @@ GetPartnersByPartnerType: Resident_GetPartnersByPartnerType_Empty_Token_Neg: endPoint: /resident/v1/auth-proxy/partners?partnerType={partnerType} role: + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerType outputTemplate: resident/error @@ -63,6 +67,7 @@ GetPartnersByPartnerType: Resident_GetPartnersByPartnerType_vid_all_Valid_Smoke: endPoint: /resident/v1/auth-proxy/partners?partnerType={partnerType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerType outputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult @@ -75,6 +80,7 @@ GetPartnersByPartnerType: Resident_GetPartnersByPartnerType_vid_Empty_PartnerType_Valid_Smoke: endPoint: /resident/v1/auth-proxy/partners?partnerType={partnerType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerType outputTemplate: resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult diff --git a/automationtests/src/main/resources/resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult.hbs b/automationtests/src/main/resources/resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult.hbs index 2c35b0f44eb..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult.hbs +++ b/automationtests/src/main/resources/resident/GetPartnersByPartnerType/getPartnersByPartnerTypeResult.hbs @@ -1,9 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs b/automationtests/src/main/resources/resident/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs index ff0878a8087..4cccb1da4bf 100644 --- a/automationtests/src/main/resources/resident/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs +++ b/automationtests/src/main/resources/resident/GetPolicyforMappedPartnerAndCredentialtype/getPolicyforMappedPartnerAndCredentialtypeResult.hbs @@ -1,36 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "partnerId": "{{partnerId}}", - "credentialType": "{{credentialType}}", - "policyId": "$IGNORE$", - "policyName": "$IGNORE$", - "policyDesc": "$IGNORE$", - "policyType": "$IGNORE$", - "publishDate": "$IGNORE$", - "validTill": "$IGNORE$", - "status": "$IGNORE$", - "version": "$IGNORE$", - "schema": "$IGNORE$", - "is_Active": "$IGNORE$", - "cr_by": "$IGNORE$", - "cr_dtimes": "$IGNORE$", - "up_by": "$IGNORE$", - "upd_dtimes": "$IGNORE$", - "policies": { - "shareableAttributes": "$IGNORE$", - "dataSharePolicies": { - "typeOfShare": "$IGNORE$", - "transactionsAllowed": "$IGNORE$", - "shareDomain": "$IGNORE$", - "encryptionType": "$IGNORE$", - "source": "$IGNORE$", - "validForInMinutes": "$IGNORE$" - } - } - }, - "errors": "$IGNORE$" + "credentialType": "{{credentialType}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetProfile/GetProfile.yml b/automationtests/src/main/resources/resident/GetProfile/GetProfile.yml index 9ba8b53e2b0..15621d81abb 100644 --- a/automationtests/src/main/resources/resident/GetProfile/GetProfile.yml +++ b/automationtests/src/main/resources/resident/GetProfile/GetProfile.yml @@ -2,6 +2,7 @@ GetProfile: Resident_GetProfile_uin_all_Valid_Smoke: endPoint: /resident/v1/profile role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetProfile/GetProfile outputTemplate: resident/GetProfile/GetProfileResult @@ -14,6 +15,7 @@ GetProfile: Resident_GetProfile_Vid_Valid_Smoke: endPoint: /resident/v1/profile role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetProfile/GetProfile outputTemplate: resident/GetProfile/GetProfileResult @@ -26,6 +28,7 @@ GetProfile: Resident_GetProfile_Invalid_User_Neg: endPoint: /resident/v1/profile role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetProfile/GetProfile outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetProfile/GetProfileResult.hbs b/automationtests/src/main/resources/resident/GetProfile/GetProfileResult.hbs index 81d819f67ea..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetProfile/GetProfileResult.hbs +++ b/automationtests/src/main/resources/resident/GetProfile/GetProfileResult.hbs @@ -1,10 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml b/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml index 2e794e655ae..714c4b2be3c 100644 --- a/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml +++ b/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml @@ -2,6 +2,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -11,15 +12,13 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "10112" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_Invalid_HierarchyLevel: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -40,6 +39,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_Invalid_Name: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -60,6 +60,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_Invalid_LangCode: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -80,6 +81,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_RandomVal_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -100,6 +102,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_RandomVal_Level_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -120,6 +123,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_RandomVal_Name_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -140,6 +144,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_StatusCode_Empty_LangCode_MandatoryFields_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -153,6 +158,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_StatusCode_Empty_Level_MandatoryFields_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -166,6 +172,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_Empty_Name_MandatoryFields_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/error @@ -186,6 +193,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: Resident_GetRegCenterByLangCodeAndHierarchyLevel_0_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -195,14 +203,12 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "MyCountry" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_1_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -212,14 +218,12 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "Rabat Sale Kenitra" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_2_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -229,14 +233,12 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "Rabat" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_3_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -246,14 +248,12 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "Rabat" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_4_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -263,14 +263,12 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "Assam" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_5_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevel outputTemplate: resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult @@ -280,7 +278,4 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "14022" }' output: '{ - "registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult.hbs b/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult.hbs index 6fa77604677..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult.hbs +++ b/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/getRegCenterByLangCodeAndHierarchyLevelResult.hbs @@ -1,36 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "registrationCenters": [ - { - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" - } - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml b/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml index 1cbd5eb65a3..9cd2475ac0b 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml @@ -2,6 +2,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult @@ -20,6 +21,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_LangCode: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -44,6 +46,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_HierarchyLevel: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -68,6 +71,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_Name: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -92,6 +96,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_PageNumber: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -116,6 +121,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_PageSize: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -140,6 +146,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_SortBy_Value: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -164,6 +171,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_OrderBy_Value: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -188,6 +196,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_Random_HierarchyLevel: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -212,6 +221,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_Random_PageNumber: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -236,6 +246,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Invalid_Random_PageSize: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -260,6 +271,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_StatusCode_LangCode_Empty_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -277,6 +289,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_StatusCode_HierarchyLevel_Empty_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -294,6 +307,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_StatusCode_Name_Empty_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/error @@ -311,6 +325,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_0_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult @@ -329,6 +344,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_1_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult @@ -347,6 +363,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_2_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult @@ -365,6 +382,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_3_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult @@ -383,6 +401,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_4_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult @@ -401,6 +420,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_5_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginated outputTemplate: resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult.hbs b/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult.hbs index 7e0b62a9517..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult.hbs +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/getRegistrationCenterByHierarchyLevelAndTextPaginatedResult.hbs @@ -1,49 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "pageNo": "$IGNORE$", - "pageSize": "$IGNORE$", - "sort": "$IGNORE$", - "totalItems": "$IGNORE$", - "totalPages": "$IGNORE$", - "data": [ - { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "$IGNORE$", - "longitude": "$IGNORE$", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "zoneCode": "$IGNORE$", - "workingNonWorkingDays": "$IGNORE$", - "exceptionalHolidayPutPostDto": "$IGNORE$" - } - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml index 0d3b1051c20..c0b97e6ca6b 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml @@ -2,6 +2,7 @@ GetRegistrationCenterWorkingDays: Resident_GetRegistrationCenterWorkingDays_allValid_smoke: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDaysResult @@ -10,12 +11,12 @@ GetRegistrationCenterWorkingDays: "registrationCenterID": "10011" }' output: '{ - "errors": null }' Resident_GetRegistrationCenterWorkingDays_Invalid_langCode: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/error @@ -35,6 +36,7 @@ GetRegistrationCenterWorkingDays: Resident_GetRegistrationCenterWorkingDays_Invalid_registrationCenterID: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/error @@ -54,6 +56,7 @@ GetRegistrationCenterWorkingDays: Resident_GetRegistrationCenterWorkingDays_Invalid_langCode_registrationCenterID: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/error @@ -73,6 +76,7 @@ GetRegistrationCenterWorkingDays: Resident_GetRegistrationCenterWorkingDays_StatusCode_Empty_registrationCenterID_Neg: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident + checkErrorsOnlyInResponse: true templateFields: ["langCode"] restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays @@ -86,6 +90,7 @@ GetRegistrationCenterWorkingDays: Resident_GetRegistrationCenterWorkingDays_StatusCode_Empty_langCode_Neg: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDaysResult.hbs b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDaysResult.hbs index 961be4c1f3f..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDaysResult.hbs +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDaysResult.hbs @@ -1,41 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "workingdays": [ - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "order": "$IGNORE$", - "languageCode": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "order": "$IGNORE$", - "languageCode": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "order": "$IGNORE$", - "languageCode": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "order": "$IGNORE$", - "languageCode": "$IGNORE$" - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "order": "$IGNORE$", - "languageCode": "$IGNORE$" - } - ] - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml index a2fa928d5d2..1a6750d77c8 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml @@ -2,6 +2,7 @@ GetRemainingupdatecountbyIndividualIdRequest: Resident_GetRemainingupdatecountbyIndividualIdRequest_Valid_Smoke: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest outputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult @@ -17,6 +18,7 @@ GetRemainingupdatecountbyIndividualIdRequest: Resident_GetRemainingupdatecountby_Invalid_IndividualIdRequest_Negative: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest outputTemplate: resident/error @@ -37,6 +39,7 @@ GetRemainingupdatecountbyIndividualIdRequest: Resident_GetRemainingupdatecountby_StatusCode_empty_IndividualIdRequest_Negative: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest outputTemplate: resident/error @@ -50,6 +53,7 @@ GetRemainingupdatecountbyIndividualIdRequest: Resident_GetRemainingupdatecountbyIndividualIdRequest_Invalid_Token: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: invalid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs index c8c7de1ec9b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs @@ -1,7 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "errors": "$IGNORE$", - "response": "$IGNORE$", - "responseTime": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2.yml b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2.yml index 426dff5f512..d2f4c1e8008 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2.yml +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2.yml @@ -2,6 +2,7 @@ GetRemainingupdatecountbyIndividualIdRequest2: Resident_GetRemainingupdatecountbyIndividualIdRequest2_uin_Valid_Smoke: endPoint: /resident/v1/identity/update-count?filter_attribute_list={filter_attribute_list} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2 outputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2Result @@ -16,6 +17,7 @@ GetRemainingupdatecountbyIndividualIdRequest2: Resident_GetRemainingupdatecountbyIndividualIdRequest2_vid_Valid_Smoke: endPoint: /resident/v1/identity/update-count?filter_attribute_list={filter_attribute_list} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2 outputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2Result @@ -30,6 +32,7 @@ GetRemainingupdatecountbyIndividualIdRequest2: Resident_GetRemainingupdatecountbyIndividualIdRequest2_Invalid_Token: endPoint: /resident/v1/identity/update-count?filter_attribute_list={filter_attribute_list} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2 outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2Result.hbs b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2Result.hbs index 394dc56d52d..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2Result.hbs +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest2/GetRemainingupdatecountbyIndividualIdRequest2Result.hbs @@ -1,8 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml index 49188121c09..09bbb50f4fe 100644 --- a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml +++ b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml @@ -62,7 +62,7 @@ GetRequestCardVid: output: '{ "errors": [ { - "errorCode": "RES-SER-406", + "errorCode": "RES-SER-454", "message": "$IGNORE$" } ] @@ -111,7 +111,7 @@ GetRequestCardVid: output: '{ "errors": [ { - "errorCode": "RES-SER-406", + "errorCode": "RES-SER-454", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVidResult.hbs b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVidResult.hbs index d4af1b45d86..0137f52daaa 100644 --- a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVidResult.hbs +++ b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVidResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.request.vid.card", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "eventId": "$IGNORE$", "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml b/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml index 791c234ed61..56a0dbe75bf 100644 --- a/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml +++ b/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml @@ -2,6 +2,7 @@ GetResidentValidDocuments: Resident_GetResidentValidDocuments_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/applicanttype/{applicantId}/languages?languages={langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetResidentValidDocuments/getResidentValidDocuments outputTemplate: resident/GetResidentValidDocuments/getResidentValidDocumentsResult @@ -10,16 +11,12 @@ GetResidentValidDocuments: "langCode":"$1STLANG$" }' output: '{ - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" }' Resident_GetResidentValidDocuments_Invalid_LangCode: endPoint: /resident/v1/proxy/masterdata/applicanttype/{applicantId}/languages?languages={langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetResidentValidDocuments/getResidentValidDocuments outputTemplate: resident/error @@ -39,6 +36,7 @@ GetResidentValidDocuments: Resident_GetResidentValidDocuments_Invalid_ApplicantId: endPoint: /resident/v1/proxy/masterdata/applicanttype/{applicantId}/languages?languages={langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetResidentValidDocuments/getResidentValidDocuments outputTemplate: resident/error @@ -58,6 +56,7 @@ GetResidentValidDocuments: Resident_GetResidentValidDocuments_Empty_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/applicanttype/{applicantId}/languages?languages={langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetResidentValidDocuments/getResidentValidDocuments outputTemplate: resident/error @@ -77,6 +76,7 @@ GetResidentValidDocuments: Resident_GetResidentValidDocuments_StatusCode_Empty_ApplicantId_Neg: endPoint: /resident/v1/proxy/masterdata/applicanttype/{applicantId}/languages?languages={langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetResidentValidDocuments/getResidentValidDocuments outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetResidentValidDocuments/getResidentValidDocumentsResult.hbs b/automationtests/src/main/resources/resident/GetResidentValidDocuments/getResidentValidDocumentsResult.hbs index fceff50472c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetResidentValidDocuments/getResidentValidDocumentsResult.hbs +++ b/automationtests/src/main/resources/resident/GetResidentValidDocuments/getResidentValidDocumentsResult.hbs @@ -1,62 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "appTypeCode": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "documentCategories": [ - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "documentTypes": [ - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "documentTypes": [ - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] - }, - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "documentTypes": [ - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - ] - } - ] - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/GetRetrieveVidPolicy.yml b/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/GetRetrieveVidPolicy.yml index 3d3abfa760c..8601334af72 100644 --- a/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/GetRetrieveVidPolicy.yml +++ b/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/GetRetrieveVidPolicy.yml @@ -2,6 +2,7 @@ GetRetrieveVidPolicy: Resident_GetRetrieveVidPolicy_uin_all_Valid_Smoke: endPoint: /resident/v1/vid/policy role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRetrieveVidPolicy/getRetrieveVidPolicy outputTemplate: resident/GetRetrieveVidPolicy/getRetrieveVidPolicyResult @@ -13,6 +14,7 @@ GetRetrieveVidPolicy: Resident_GetRetrieveVidPolicy_vid_all_Valid_Smoke: endPoint: /resident/v1/vid/policy role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRetrieveVidPolicy/getRetrieveVidPolicy outputTemplate: resident/GetRetrieveVidPolicy/getRetrieveVidPolicyResult diff --git a/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/getRetrieveVidPolicyResult.hbs b/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/getRetrieveVidPolicyResult.hbs index b20bad4f914..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/getRetrieveVidPolicyResult.hbs +++ b/automationtests/src/main/resources/resident/GetRetrieveVidPolicy/getRetrieveVidPolicyResult.hbs @@ -1,8 +1 @@ -{ - "id": "mosip.resident.vid.policy", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": {}, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualId.yml b/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualId.yml index f831affdf2b..f65ce77e318 100644 --- a/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualId.yml +++ b/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualId.yml @@ -2,6 +2,7 @@ GetRidByIndividualId: Resident_GetRidByIndividualId_all_Valid_Smoke: endPoint: /idrepository/v1/identity/rid/{individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRidByIndividualId/GetRidByIndividualId outputTemplate: resident/GetRidByIndividualId/GetRidByIndividualIdResult @@ -15,6 +16,7 @@ GetRidByIndividualId: Resident_GetRidByIndividualId_Perp_Vid_all_Valid_Smoke: endPoint: /idrepository/v1/identity/rid/{individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRidByIndividualId/GetRidByIndividualId outputTemplate: resident/GetRidByIndividualId/GetRidByIndividualIdResult @@ -28,6 +30,7 @@ GetRidByIndividualId: Resident_GetRidByIndividualId_OneTime_Vid_Valid_Smoke: endPoint: /idrepository/v1/identity/rid/{individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRidByIndividualId/GetRidByIndividualId outputTemplate: resident/GetRidByIndividualId/GetRidByIndividualIdResult @@ -41,6 +44,7 @@ GetRidByIndividualId: Resident_GetRidByIndividualId_Temp_Vid_all_Valid_Smoke: endPoint: /idrepository/v1/identity/rid/{individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRidByIndividualId/GetRidByIndividualId outputTemplate: resident/GetRidByIndividualId/GetRidByIndividualIdResult diff --git a/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualIdResult.hbs b/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualIdResult.hbs index e440678b785..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualIdResult.hbs +++ b/automationtests/src/main/resources/resident/GetRidByIndividualId/GetRidByIndividualIdResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.idrepo.rid.get", - "version": "1.0", - "errors": "$IGNORE$", - "response": { - "rid": "$IGNORE$" - }, - "responseTime": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml index 0b40771b3cf..3eac5ec983e 100644 --- a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml +++ b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml @@ -2,6 +2,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_all_Valid_Smoke_sid: endPoint: /resident/v1/service-history/{langcode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get auditLogCheck: true inputTemplate: resident/GetServiceHistory/GetServiceHistory @@ -24,6 +25,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_LangCode_Neg: endPoint: /resident/v1/service-history/{langcode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -50,6 +52,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_StatusCode_Missing_Langcode_Neg: endPoint: /resident/v1/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -69,6 +72,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_1_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -90,6 +94,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_2_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -111,6 +116,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_3_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -132,6 +138,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_4_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -153,6 +160,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_5_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -174,6 +182,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Date_Specified_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -195,6 +204,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_FromDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -221,6 +231,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_From_To_Date_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -247,6 +258,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Empty_FromDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -273,6 +285,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Empty_ToDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -299,6 +312,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_PageStart_Neg: endPoint: /resident/v1/service-history/{langcode}?pageStart={pageStart} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -325,6 +339,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Valid_PageStart_Smoke: endPoint: /resident/v1/service-history/{langcode}?pageStart={pageStart} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -351,6 +366,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Negative_PageFetch_Value_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -377,6 +393,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_Random_PageFetch_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -403,6 +420,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_PageFetch_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -429,6 +447,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Multiple_ServiceType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -455,6 +474,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_ASC_SortType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -476,6 +496,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_DESC_SortType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -497,6 +518,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Empty_SortType_Neg: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -523,6 +545,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_SortType_Neg: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -549,6 +572,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_SearchText_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -570,6 +594,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_0_SearchText_Pos: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -591,6 +616,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_SearchText_Random_Pos: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -612,6 +638,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_StatusFilter_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?statusFilter={statusFilter} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -633,6 +660,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_StatusFilter_Invalid_Neg: endPoint: /resident/v1/service-history/{langcode}?statusFilter={statusFilter} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -659,6 +687,7 @@ GetServiceHistory: Resident_GetServiceHistory_Invalid_Token: endPoint: /resident/v1/service-history/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -685,6 +714,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_all_Valid_Smoke_sid: endPoint: /resident/v1/service-history/{langcode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -706,6 +736,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_LangCode_Neg: endPoint: /resident/v1/service-history/{langcode} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -732,6 +763,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_StatusCode_Missing_Langcode_Neg: endPoint: /resident/v1/service-history role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -751,6 +783,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_1_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -772,6 +805,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_2_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -793,6 +827,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_3_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -814,6 +849,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_4_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -835,6 +871,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_5_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -856,6 +893,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Date_Specified_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -877,6 +915,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_FromDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -903,6 +942,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_From_To_Date_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -929,6 +969,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Empty_FromDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -955,6 +996,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Empty_ToDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -981,6 +1023,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_PageStart_Neg: endPoint: /resident/v1/service-history/{langcode}?pageStart={pageStart} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1007,6 +1050,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Valid_PageStart_Smoke: endPoint: /resident/v1/service-history/{langcode}?pageStart={pageStart} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1033,6 +1077,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Negative_PageFetch_Value_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1059,6 +1104,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_Random_PageFetch_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1085,6 +1131,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_PageFetch_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1111,6 +1158,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Multiple_ServiceType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1137,6 +1185,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_ASC_SortType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1158,6 +1207,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_DESC_SortType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1179,6 +1229,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Empty_SortType_Neg: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1205,6 +1256,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_Invalid_SortType_Neg: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1231,6 +1283,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_SearchText_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1252,6 +1305,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_0_SearchText_Pos: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1273,6 +1327,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_SearchText_Random_Pos: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1294,6 +1349,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_StatusFilter_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?statusFilter={statusFilter} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1315,6 +1371,7 @@ GetServiceHistory: Resident_GetServiceHistory_uin_StatusFilter_Invalid_Neg: endPoint: /resident/v1/service-history/{langcode}?statusFilter={statusFilter} role: residentNew + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1340,6 +1397,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_all_Valid_Smoke_sid: endPoint: /resident/v1/service-history/{langcode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1361,6 +1419,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_LangCode_Neg: endPoint: /resident/v1/service-history/{langcode} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1387,6 +1446,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_StatusCode_Missing_Langcode_Neg: endPoint: /resident/v1/service-history role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1406,6 +1466,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_1_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1427,6 +1488,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_2_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1448,6 +1510,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_3_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1469,6 +1532,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_4_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1490,6 +1554,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_5_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1511,6 +1576,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Date_Specified_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1532,6 +1598,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_FromDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1558,6 +1625,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_From_To_Date_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1584,6 +1652,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Empty_FromDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1610,6 +1679,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Empty_ToDate_Neg: endPoint: /resident/v1/service-history/{langcode}?fromDate={fromDate}&toDate={toDate} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1636,6 +1706,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_PageStart_Neg: endPoint: /resident/v1/service-history/{langcode}?pageStart={pageStart} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1662,6 +1733,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Valid_PageStart_Smoke: endPoint: /resident/v1/service-history/{langcode}?pageStart={pageStart} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1688,6 +1760,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Negative_PageFetch_Value_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1714,6 +1787,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_Random_PageFetch_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1740,6 +1814,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_PageFetch_Neg: endPoint: /resident/v1/service-history/{langcode}?pageFetch={pageFetch} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1766,6 +1841,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Multiple_ServiceType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?serviceType={serviceType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1792,6 +1868,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_ASC_SortType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1813,6 +1890,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_DESC_SortType_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1834,6 +1912,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Empty_SortType_Neg: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1860,6 +1939,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_Invalid_SortType_Neg: endPoint: /resident/v1/service-history/{langcode}?sortType={sortType} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1886,6 +1966,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_SearchText_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1907,6 +1988,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_0_SearchText_Pos: endPoint: /resident/v1/service-history/{langcode}?searchText={searchText} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1930,6 +2012,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_StatusFilter_Valid_Smoke: endPoint: /resident/v1/service-history/{langcode}?statusFilter={statusFilter} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/GetServiceHistory/GetServiceHistoryResult @@ -1951,6 +2034,7 @@ GetServiceHistory: Resident_GetServiceHistory_vid_StatusFilter_Invalid_Neg: endPoint: /resident/v1/service-history/{langcode}?statusFilter={statusFilter} role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error @@ -1976,6 +2060,7 @@ GetServiceHistory: Resident_GetServiceHistory_StatusCode_Empty_Token: endPoint: /resident/v1/service-history/{langcode} role: + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetServiceHistory/GetServiceHistory outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistoryResult.hbs b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistoryResult.hbs index 006b13fd22e..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistoryResult.hbs +++ b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistoryResult.hbs @@ -1,26 +1 @@ -{ - "id": "mosip.service.history.get", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "pageSize": "$IGNORE$", - "totalItems": "$IGNORE$", - "totalPages": "$IGNORE$", - "data": [ - {{#each data}} - { - "eventId": "$IGNORE$", - "description": "$IGNORE$", - "eventStatus": "$IGNORE$", - "timeStamp": "$IGNORE$", - "requestType": "$IGNORE$", - "pinnedStatus": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDoc.yml b/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDoc.yml index 9680de34356..ca262c57deb 100644 --- a/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDoc.yml +++ b/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDoc.yml @@ -2,6 +2,7 @@ GetSupportingDoc: Resident_GetSupportingDoc_all_Valid_Smoke: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetSupportingDoc/GetSupportingDoc outputTemplate: resident/GetSupportingDoc/GetSupportingDocResult @@ -15,6 +16,7 @@ GetSupportingDoc: Resident_GetSupportingDoc_Invalid_Langcode_Neg: endPoint: /resident/v1/download/supporting-documents role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetSupportingDoc/GetSupportingDoc outputTemplate: resident/GetSupportingDoc/GetSupportingDocResult diff --git a/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDocResult.hbs b/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDocResult.hbs index 4d883bd7fb4..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDocResult.hbs +++ b/automationtests/src/main/resources/resident/GetSupportingDoc/GetSupportingDocResult.hbs @@ -1,10 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml b/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml index 3e2c1d5166b..eb567a903db 100644 --- a/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml +++ b/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml @@ -9,13 +9,4 @@ GetUiProperties: input: '{ }' output: '{ - "mosip.resident.api.id.auth": "{{mosip.resident.api.id.auth}}", - "mosip.resident.api.version.otp.request": "{{mosip.resident.api.version.otp.request}}", - "resident.datetime.pattern": "$IGNORE$", - "mosip.mandatory-languages": "$IGNORE$", - "mosip.resident.api.version.auth": "{{mosip.resident.api.version.auth}}", - "mosip.optional-languages": "$IGNORE$", - "mosip.resident.api.id.otp.request": "{{mosip.resident.api.id.otp.request}}", - "mosip.utc-datetime-pattern": "$IGNORE$", - "mosip.iam.adapter.clientid": "{{mosip.iam.adapter.clientid}}" -}' +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetUiProperties/getUiPropertiesResult.hbs b/automationtests/src/main/resources/resident/GetUiProperties/getUiPropertiesResult.hbs index 3acf7ad733f..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetUiProperties/getUiPropertiesResult.hbs +++ b/automationtests/src/main/resources/resident/GetUiProperties/getUiPropertiesResult.hbs @@ -1,18 +1 @@ -{ - "id": "resident.ui.properties", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "mosip.resident.api.id.auth": "mosip.identity.auth.internal", - "mosip.resident.api.version.otp.request": "1.0", - "resident.datetime.pattern": "$IGNORE$", - "mosip.mandatory-languages": "$IGNORE$", - "mosip.resident.api.version.auth": "1.0", - "mosip.optional-languages": "$IGNORE$", - "mosip.resident.api.id.otp.request": "mosip.identity.otp.internal", - "mosip.utc-datetime-pattern": "$IGNORE$", - "mosip.iam.adapter.clientid": "mosip-resident-client" - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml index fddb43ab5af..26e18d79a83 100644 --- a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml +++ b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml @@ -10,9 +10,6 @@ GetValidDocumentByLangCode: "langCode": "$1STLANG$" }' output: '{ - "response": [{ - - }] }' @@ -20,6 +17,7 @@ GetValidDocumentByLangCode: Resident_GetValidDocumentByLangCode_Invalid_LangCode: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCode outputTemplate: resident/error @@ -52,6 +50,7 @@ GetValidDocumentByLangCode: Resident_GetValidDocumentByLangCode_StatusCode_Empty_Invalid_Neg: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCode outputTemplate: resident/error @@ -63,6 +62,7 @@ GetValidDocumentByLangCode: Resident_GetValidDocumentByLangCode_Invalid_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCode outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/getValidDocumentByLangCodeResult.hbs b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/getValidDocumentByLangCodeResult.hbs index 42d7f228381..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/getValidDocumentByLangCodeResult.hbs +++ b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/getValidDocumentByLangCodeResult.hbs @@ -1,33 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "documentcategories": [ - {{#each documentcategories}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$", - "documenttypes": [ - {{#each documenttypes}} - { - "code": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - }, - "errors": $IGNORE$ -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetValidateToken/GetValidateToken.yml b/automationtests/src/main/resources/resident/GetValidateToken/GetValidateToken.yml index 50318b0b1e2..37a0af6270b 100644 --- a/automationtests/src/main/resources/resident/GetValidateToken/GetValidateToken.yml +++ b/automationtests/src/main/resources/resident/GetValidateToken/GetValidateToken.yml @@ -2,6 +2,7 @@ GetValidateToken: Resident_GetValidateToken_uin_all_Valid_Smoke: endPoint: /resident/v1/authorize/admin/validateToken role: residentNew + checkErrorsOnlyInResponse: true restMethod: get auditLogCheck: true inputTemplate: resident/GetValidateToken/getValidateToken @@ -14,6 +15,7 @@ GetValidateToken: Resident_GetValidateToken_vid_all_Valid_Smoke: endPoint: /resident/v1/authorize/admin/validateToken role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidateToken/getValidateToken outputTemplate: resident/GetValidateToken/getValidateTokenResult @@ -26,6 +28,7 @@ GetValidateToken: Resident_GetValidateToken_Invalid_Token: endPoint: /resident/v1/authorize/admin/validateToken role: invalid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidateToken/getValidateToken outputTemplate: resident/error @@ -43,6 +46,7 @@ GetValidateToken: Resident_GetValidateToken_Empty_Token_Neg: endPoint: /resident/v1/authorize/admin/validateToken role: + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidateToken/getValidateToken outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GetValidateToken/getValidateTokenResult.hbs b/automationtests/src/main/resources/resident/GetValidateToken/getValidateTokenResult.hbs index 38b95b914e0..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GetValidateToken/getValidateTokenResult.hbs +++ b/automationtests/src/main/resources/resident/GetValidateToken/getValidateTokenResult.hbs @@ -1,9 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicket.yml b/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicket.yml index 59b688f9b8e..337b69c44e7 100644 --- a/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicket.yml +++ b/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicket.yml @@ -2,6 +2,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_all_Valid_Smoke: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/GrievanceTicket/GrievanceTicketResult @@ -22,6 +23,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_InvalidUser_Token_Neg: endPoint: /resident/v1/grievance/ticket role: resident + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket @@ -48,6 +50,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_StatusCode_Invalid_Token_Neg: endPoint: /resident/v1/grievance/ticket role: invalid + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket @@ -67,6 +70,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_StatusCode_Empty_Token_Neg: endPoint: /resident/v1/grievance/ticket role: + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket @@ -86,6 +90,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_Invalid_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -111,6 +116,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_Diff_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -136,6 +142,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_Missing_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -161,6 +168,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_Empty_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -186,6 +194,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_Empty_Msg_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -211,6 +220,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_Missing_Msg_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -236,6 +246,7 @@ GrievanceTicket: Resident_GrievanceTicket_uin_OverRange_Msg_Neg: endPoint: /resident/v1/grievance/ticket role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -261,6 +272,7 @@ GrievanceTicket: Resident_GrievanceTicket_vid_all_Valid_Smoke: endPoint: /resident/v1/grievance/ticket role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/GrievanceTicket/GrievanceTicketResult @@ -281,6 +293,7 @@ GrievanceTicket: Resident_GrievanceTicket_vid_Invalid_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -306,6 +319,7 @@ GrievanceTicket: Resident_GrievanceTicket_vid_Diff_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -331,6 +345,7 @@ GrievanceTicket: Resident_GrievanceTicket_vid_Missing_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error @@ -356,6 +371,7 @@ GrievanceTicket: Resident_GrievanceTicket_vid_Empty_Eid_Neg: endPoint: /resident/v1/grievance/ticket role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GrievanceTicket/GrievanceTicket outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicketResult.hbs b/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicketResult.hbs index afe6f5c4b3e..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicketResult.hbs +++ b/automationtests/src/main/resources/resident/GrievanceTicket/GrievanceTicketResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.resident.grievance.ticket.request", - "version": "1.0", - "responseTime": "$IGNORE$", - "response": { - "ticketId" : "$IGNORE$" - }, - "errors" : "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/LoginUri/LoginUri.yml b/automationtests/src/main/resources/resident/LoginUri/LoginUri.yml index cf1a83564ef..52e3a510954 100644 --- a/automationtests/src/main/resources/resident/LoginUri/LoginUri.yml +++ b/automationtests/src/main/resources/resident/LoginUri/LoginUri.yml @@ -2,6 +2,7 @@ LoginUri: Resident_LoginUri_all_Valid_Smoke: endPoint: /resident/v1/login/{redirectURI} role: state + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/LoginUri/LoginUri outputTemplate: resident/LoginUri/LoginUriResult diff --git a/automationtests/src/main/resources/resident/LoginUri/LoginUriResult.hbs b/automationtests/src/main/resources/resident/LoginUri/LoginUriResult.hbs index c192f376929..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/LoginUri/LoginUriResult.hbs +++ b/automationtests/src/main/resources/resident/LoginUri/LoginUriResult.hbs @@ -1,10 +1 @@ -{ - "id": null, - "version": null, - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs b/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs index 3a0c7968ea6..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs +++ b/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequestResult.hbs @@ -1,16 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "response": { - "transactionId": "$IGNORE$", - "clientName": "$IGNORE$", - "logoUrl": "$IGNORE$", - "authFactors": "$IGNORE$", - "authorizeScopes": "$IGNORE$", - "essentialClaims": "$IGNORE$", - "voluntaryClaims": "$IGNORE$", - "configs": "$IGNORE$" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/PRINTUIN/createPrintUin.yml b/automationtests/src/main/resources/resident/PRINTUIN/createPrintUin.yml index fb1e52959e9..c4793f99e5e 100644 --- a/automationtests/src/main/resources/resident/PRINTUIN/createPrintUin.yml +++ b/automationtests/src/main/resources/resident/PRINTUIN/createPrintUin.yml @@ -2,6 +2,7 @@ PrintUin: Resident_PrintUin_All_Valid_Smoke: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/PRINTUIN/createPrintUinResult @@ -24,8 +25,6 @@ PrintUin: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -35,6 +34,7 @@ PrintUin: Resident_PrintUin_Invalid_Empty_Cardtype_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -109,6 +109,7 @@ PrintUin: Resident_PrintUin_Invalid_Missing_Cardtype_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -146,6 +147,7 @@ PrintUin: Resident_PrintUin_Invalid_IndividualIDType_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -183,6 +185,7 @@ PrintUin: Resident_PrintUin_Invalid_MaxLength3_IndividualIDType_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -220,6 +223,7 @@ PrintUin: Resident_PrintUin_Invalid_Missing_IndividualID_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -257,6 +261,7 @@ PrintUin: Resident_PrintUin_Invalid_Empty_Otp_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -294,6 +299,7 @@ PrintUin: Resident_PrintUin_Invalid_MaxLength6_Otp_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -331,6 +337,7 @@ PrintUin: Resident_PrintUin_Invalid_Otp_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -368,6 +375,7 @@ PrintUin: Resident_PrintUin_Invalid_Empty_requestTime_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -405,6 +413,7 @@ PrintUin: Resident_PrintUin_Invalid_Empty_TrnxID_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -442,6 +451,7 @@ PrintUin: Resident_PrintUin_Invalid_Value_TrnxID_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -479,6 +489,7 @@ PrintUin: Resident_PrintUin_Invalid_Empty_version_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -516,6 +527,7 @@ PrintUin: Resident_PrintUin_Invalid_version_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -553,6 +565,7 @@ PrintUin: Resident_PrintUin_Invalid_Individual_Id_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -590,6 +603,7 @@ PrintUin: Resident_PrintUin_Missing_Individual_Id_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error @@ -627,6 +641,7 @@ PrintUin: Resident_PrintUin_Empty_Individual_Id_Neg: endPoint: /resident/v1/req/print-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PRINTUIN/createPrintUin outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs b/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs index c65f625f47b..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs +++ b/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs @@ -1,11 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "registrationId": "{{registrationId}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCard.yml b/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCard.yml index 21f34811e87..22fd9776b3d 100644 --- a/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCard.yml +++ b/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCard.yml @@ -2,6 +2,7 @@ PersonalizedCard: Resident_PersonalizedCard_uin_all_Valid_Smoke: endPoint: /resident/v1/download/personalized-card role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/PersonalizedCard/PersonalizedCardResult @@ -17,6 +18,7 @@ PersonalizedCard: Resident_PersonalizedCard_vid_all_Valid_Smoke: endPoint: /resident/v1/download/personalized-card role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/PersonalizedCard/PersonalizedCardResult @@ -32,6 +34,7 @@ PersonalizedCard: Resident_PersonalizedCard_Empty_Access_Token_Neg: endPoint: /resident/v1/download/personalized-card role: + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/error @@ -53,6 +56,7 @@ PersonalizedCard: Resident_PersonalizedCard_Invalid_Access_Token_Neg: endPoint: /resident/v1/download/personalized-card role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/error @@ -74,6 +78,7 @@ PersonalizedCard: Resident_PersonalizedCard_uin_Invalid_Html_Neg: endPoint: /resident/v1/download/personalized-card role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/error @@ -95,6 +100,7 @@ PersonalizedCard: Resident_PersonalizedCard_uin_Empty_Html_Neg: endPoint: /resident/v1/download/personalized-card role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/error @@ -116,6 +122,7 @@ PersonalizedCard: Resident_PersonalizedCard_vid_Invalid_Html_Neg: endPoint: /resident/v1/download/personalized-card role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/error @@ -137,6 +144,7 @@ PersonalizedCard: Resident_PersonalizedCard_vid_Empty_Html_Neg: endPoint: /resident/v1/download/personalized-card role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/PersonalizedCard/PersonalizedCard outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCardResult.hbs b/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCardResult.hbs index 2d481b104f3..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCardResult.hbs +++ b/automationtests/src/main/resources/resident/PersonalizedCard/PersonalizedCardResult.hbs @@ -1,13 +1 @@ -{ - "id": "mosip.resident.download.personalized.card", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": $IGNORE$, - "errors": [ - { - "errorCode": "$IGNORE$", - "message": "$IGNORE$" - } - ] -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/PinStatus/PinStatus.yml b/automationtests/src/main/resources/resident/PinStatus/PinStatus.yml index bad0987b229..0bbe55fdf28 100644 --- a/automationtests/src/main/resources/resident/PinStatus/PinStatus.yml +++ b/automationtests/src/main/resources/resident/PinStatus/PinStatus.yml @@ -9,8 +9,7 @@ PinStatus: "eventId": "$ID:GetServiceHistory_uin_all_Valid_Smoke_sid_eventId$" }' output: '{ - "status": "200", - "message": "SUCCESS" + "status": "200" }' Resident_PinStatus_vid_all_Valid_Smoke: @@ -23,8 +22,7 @@ PinStatus: "eventId": "$ID:GetServiceHistory_vid_all_Valid_Smoke_sid_eventId$" }' output: '{ - "status": "200", - "message": "SUCCESS" + "status": "200" }' Resident_PinStatus_uin_Invalid_Input_Neg: diff --git a/automationtests/src/main/resources/resident/PinStatus/PinStatusResult.hbs b/automationtests/src/main/resources/resident/PinStatus/PinStatusResult.hbs index 6573a3ca427..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/PinStatus/PinStatusResult.hbs +++ b/automationtests/src/main/resources/resident/PinStatus/PinStatusResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.resident.pin.status", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTime.yml b/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTime.yml index c7d85d9befd..cf7aabb66cb 100644 --- a/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTime.yml +++ b/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTime.yml @@ -2,6 +2,7 @@ PutBellUpdatedTime: Resident_PutBellUpdatedTime_uin_StatusCode_all_Valid_Smoke: endPoint: /resident/v1/bell/updatedttime role: residentNew + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: resident/PutBellUpdatedTime/PutBellUpdatedTime outputTemplate: resident/PutBellUpdatedTime/PutBellUpdatedTimeResult @@ -12,6 +13,7 @@ PutBellUpdatedTime: Resident_PutBellUpdatedTime_Invalid_Token: endPoint: /resident/v1/bell/updatedttime role: resident + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: resident/PutBellUpdatedTime/PutBellUpdatedTime outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTimeResult.hbs b/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTimeResult.hbs index 35b07affb15..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTimeResult.hbs +++ b/automationtests/src/main/resources/resident/PutBellUpdatedTime/PutBellUpdatedTimeResult.hbs @@ -1,6 +1 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/ReqAidOtp/ReqAidOtpResult.hbs b/automationtests/src/main/resources/resident/ReqAidOtp/ReqAidOtpResult.hbs index 0b2ee0c152f..0a63321ce5b 100644 --- a/automationtests/src/main/resources/resident/ReqAidOtp/ReqAidOtpResult.hbs +++ b/automationtests/src/main/resources/resident/ReqAidOtp/ReqAidOtpResult.hbs @@ -1,12 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", - "transactionId": "$IGNORE$", - "responseTime": "$IGNORE$", - "errors": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" - }, - "metadata": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/ReqShareCredWithPartner/ReqShareCredWithPartnerResult.hbs b/automationtests/src/main/resources/resident/ReqShareCredWithPartner/ReqShareCredWithPartnerResult.hbs index 8cae36b27dc..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/ReqShareCredWithPartner/ReqShareCredWithPartnerResult.hbs +++ b/automationtests/src/main/resources/resident/ReqShareCredWithPartner/ReqShareCredWithPartnerResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.share.credential", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "status": "{{status}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVID.yml b/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVID.yml index c4d4d9f14f1..242358ed92f 100644 --- a/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVID.yml +++ b/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVID.yml @@ -2,6 +2,7 @@ RetrieveVID: Resident_RetrieveVID_uin_all_Valid_Smoke: endPoint: /resident/v1/vids role: residentNew + checkErrorsOnlyInResponse: true restMethod: get auditLogCheck: true inputTemplate: resident/RetrieveVID/RetrieveVID @@ -14,6 +15,7 @@ RetrieveVID: Resident_RetrieveVID_Vid_all_Valid_Smoke: endPoint: /resident/v1/vids role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/RetrieveVID/RetrieveVID outputTemplate: resident/RetrieveVID/RetrieveVIDResult @@ -25,6 +27,7 @@ RetrieveVID: Resident_RetrieveVID_Invalid_Token_Neg: endPoint: /resident/v1/vids role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/RetrieveVID/RetrieveVID outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVIDResult.hbs b/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVIDResult.hbs index 0deefa4400c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVIDResult.hbs +++ b/automationtests/src/main/resources/resident/RetrieveVID/RetrieveVIDResult.hbs @@ -1,20 +1 @@ -{ - "id": "mosip.resident.vid.get", - "version": "1.0", - "responsetime": "$IGNORE$", - "response": [ - {{#each response}} - { - "vid": "$IGNORE$", - "maskedVid": "$IGNORE$", - "vidType": "$IGNORE$", - "expiryTimestamp": "$IGNORE$", - "transactionLimit": "$IGNORE$", - "transactionsLeftCount": "$IGNORE$", - "generatedOnTimestamp": "$IGNORE$" - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/RevokeVID/createRevokeVID.yml b/automationtests/src/main/resources/resident/RevokeVID/createRevokeVID.yml index a27959f0bd9..edf46d1bf75 100644 --- a/automationtests/src/main/resources/resident/RevokeVID/createRevokeVID.yml +++ b/automationtests/src/main/resources/resident/RevokeVID/createRevokeVID.yml @@ -2,6 +2,7 @@ RevokeVID: Resident_Revoke_Perpetual_VID_UsingSameVID_Invalid: endPoint: /resident/v1/vid/$ID:GenerateVID_Perpetual_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -40,6 +41,7 @@ RevokeVID: Resident_Revoke_Temporary_VID_UsingSameVID_Invalid: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -78,6 +80,7 @@ RevokeVID: Resident_Revoke_Onetimeuse_VID_UsingSameVID_Invalid: endPoint: /resident/v1/vid/$ID:GenerateVID_Onetimeuse_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -116,6 +119,7 @@ RevokeVID: Resident_RevokeVID_Invalid_Id: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -154,6 +158,7 @@ RevokeVID: Resident_RevokeVID_Missing_Id: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -192,6 +197,7 @@ RevokeVID: Resident_RevokeVID_Empty_Id: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -230,6 +236,7 @@ RevokeVID: Resident_RevokeVID_Invalid_Individual_Id: endPoint: /resident/v1/vid/@234rff role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -267,6 +274,7 @@ RevokeVID: Resident_RevokeVID_Missing_Individual_Id: endPoint: /resident/v1/vid/$REMOVE$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -305,6 +313,7 @@ RevokeVID: Resident_RevokeVID_Empty_Individual_Id: endPoint: /resident/v1/vid/"" role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -342,6 +351,7 @@ RevokeVID: Resident_RevokeVID_Missing_Request_Time: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -379,6 +389,7 @@ RevokeVID: Resident_RevokeVID_Invalid_Request_Time: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -417,6 +428,7 @@ RevokeVID: Resident_RevokeVID_Empty_Request_Time: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -455,6 +467,7 @@ RevokeVID: Resident_RevokeVID_Invalid_version: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -492,6 +505,7 @@ RevokeVID: Resident_RevokeVID_Missing_version: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -530,6 +544,7 @@ RevokeVID: Resident_RevokeVID_Empty_version: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -568,6 +583,7 @@ RevokeVID: Resident_RevokeVID_Empty_transactionID: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -606,6 +622,7 @@ RevokeVID: Resident_RevokeVID_Invalid_transactionID: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -644,6 +661,7 @@ RevokeVID: Resident_RevokeVID_Missing_transactionID: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -682,6 +700,7 @@ RevokeVID: Resident_RevokeVID_Missing_vid_status: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -719,6 +738,7 @@ RevokeVID: Resident_RevokeVID_Invalid_vidstatus: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -757,6 +777,7 @@ RevokeVID: Resident_RevokeVID_Empty_vidstatus: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -795,6 +816,7 @@ RevokeVID: Resident_Revoke_Temporary_VID_UsingPerpVID_Valid_Smoke: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/RevokeVID/createRevokeVIDResult @@ -817,7 +839,6 @@ RevokeVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -828,6 +849,7 @@ RevokeVID: Resident_Revoke_Temporary_VID_UsingTempVID_Valid_Smoke: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_2_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/RevokeVID/createRevokeVIDResult @@ -850,7 +872,6 @@ RevokeVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -861,6 +882,7 @@ RevokeVID: Resident_Revoke_Temporary_VID_UsingOnetimeVID_Valid_Smoke: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_3_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/RevokeVID/createRevokeVIDResult @@ -883,7 +905,6 @@ RevokeVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -894,6 +915,7 @@ RevokeVID: Resident_Revoke_Perpetual_VID_UsingUIN_Valid_Smoke: endPoint: /resident/v1/vid/$ID:GenerateVID_Perpetual_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/RevokeVID/createRevokeVIDResult @@ -916,7 +938,6 @@ RevokeVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -927,6 +948,7 @@ RevokeVID: Resident_Revoke_Onetimeuse_VID_UsingUIN_Valid_Smoke: endPoint: /resident/v1/vid/$ID:GenerateVID_Onetimeuse_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/RevokeVID/createRevokeVIDResult @@ -949,7 +971,6 @@ RevokeVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -960,6 +981,7 @@ RevokeVID: Resident_Revoke_Temporary_VID_UsingUIN_Valid_Smoke: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_4_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/RevokeVID/createRevokeVIDResult @@ -982,7 +1004,6 @@ RevokeVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -993,6 +1014,7 @@ RevokeVID: Resident_Revoke_Expired_Perpetual_VID_Neg: endPoint: /resident/v1/vid/$ID:GenerateVID_Perpetual_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -1031,6 +1053,7 @@ RevokeVID: Resident_Revoke_Expired_Temp_VID_Neg: endPoint: /resident/v1/vid/$ID:GenerateVID_Temporary_1_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error @@ -1069,6 +1092,7 @@ RevokeVID: Resident_Revoke_Expired_Onetimeuse_VID_Neg: endPoint: /resident/v1/vid/$ID:GenerateVID_Onetimeuse_Using_RevokeUIN_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVID/createRevokeVID outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/RevokeVID/createRevokeVIDResult.hbs b/automationtests/src/main/resources/resident/RevokeVID/createRevokeVIDResult.hbs index 1e2ddabc7ec..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/RevokeVID/createRevokeVIDResult.hbs +++ b/automationtests/src/main/resources/resident/RevokeVID/createRevokeVIDResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.resident.vidstatus", - "version": "v1", - "responsetime": "$IGNORE$", - "response": { - "message": "{{message}}" - }, - "errors": "$IGNORE$" -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml index dd257b30fcd..efe1eed774f 100644 --- a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml +++ b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml @@ -2,6 +2,7 @@ RevokeVIDNew: Resident_RevokeVIDNew_uin_Perp_Valid_Smoke: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Perpetual_VID_uin_Valid_Token_Smoke_sid_vid$ role: residentNew + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNewResult @@ -13,12 +14,12 @@ RevokeVIDNew: "vidStatus": "Revoked" }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)" }' Resident_RevokeVIDNew_uin_Temp_Valid_Smoke: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_uin_Temporary_VID_Valid_Smoke_sid_vid$ role: residentNew + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNewResult @@ -30,12 +31,12 @@ RevokeVIDNew: "vidStatus": "Revoked" }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)" }' Resident_RevokeVIDNew_uin_OneTimeUse_Valid_Smoke: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_uin_Onetimeuse_VID_Valid_Smoke_sid_vid$ role: residentNew + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNewResult @@ -47,12 +48,12 @@ RevokeVIDNew: "vidStatus": "Revoked" }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)" }' Resident_RevokeVIDNew_StatusCode_Without_Token_Neg: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_1_Esignet_Integ_Valid_Smoke_sid_vid$ role: + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/error @@ -68,6 +69,7 @@ RevokeVIDNew: Resident_RevokeVIDNew_Diff_Token_Neg: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_1_Esignet_Integ_Valid_Smoke_sid_vid$ role: resident + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/error @@ -89,6 +91,7 @@ RevokeVIDNew: Resident_RevokeVIDNew_Using_Vid_Valid_Neg: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_1_Esignet_Integ_Valid_Smoke_sid_vid$ role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/error @@ -111,6 +114,7 @@ RevokeVIDNew: Resident_RevokeVIDNew_uin_Using_Vid_Invalid_User_Neg: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_2_Esignet_Integ_Valid_Smoke_sid_vid$ role: residentNew + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew outputTemplate: resident/error @@ -124,7 +128,7 @@ RevokeVIDNew: output: '{ "errors": [ { - "errorCode": "RES-SER-454", + "errorCode": "RES-SER-407", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNewResult.hbs b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNewResult.hbs index 90fab06b72d..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNewResult.hbs +++ b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNewResult.hbs @@ -1,9 +1 @@ -{ - "id": "mosip.resident.vid.revoke", - "version": "1.0", - "responsetime": "$IGNORE$", - "response": { - "message": "{{message}}" - }, - "errors": [] -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml index f8bd92eb49a..0a89e6ef08a 100644 --- a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml +++ b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml @@ -13,11 +13,11 @@ RidCheckStatus: "requesttime": "$TIMESTAMP$" }' output: '{ - "ridStatus": "$IGNORE$" }' Resident_RidCheckStatus_Missing_InputParameter_individualId: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error @@ -38,6 +38,7 @@ RidCheckStatus: Resident_RidCheckStatus_Invalid_InputParameter_individualId: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error @@ -59,6 +60,7 @@ RidCheckStatus: Resident_RidCheckStatus_Missing_InputParameter_individualIdType: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error @@ -79,6 +81,7 @@ RidCheckStatus: Resident_RidCheckStatus_Invalid_InputParameter_individualIdType: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error @@ -99,6 +102,7 @@ RidCheckStatus: Resident_RidCheckStatus_Missing_Id: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error @@ -119,6 +123,7 @@ RidCheckStatus: Resident_RidCheckStatus_Missing_timestamp: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error @@ -139,6 +144,7 @@ RidCheckStatus: Resident_RidCheckStatus_Invalid_timestamp: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatusResult.hbs b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatusResult.hbs index fc7f184c63a..03dcf612b4c 100644 --- a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatusResult.hbs +++ b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatusResult.hbs @@ -1,10 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "ridStatus": "{{ridStatus}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult.hbs index c8368800969..8c134ae435d 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult.hbs @@ -1,14 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", "errors": [ { - "errorCode": "{{errorCode}}", - "errorMessage": "{{errorMessage}}" + "errorCode": "{{errorCode}}" } ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult2.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult2.hbs index 1216fda84a0..8c134ae435d 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult2.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPErrorResult2.hbs @@ -1,14 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", "errors": [ { - "errorCode": "{{errorCode}}", - "message": "{{message}}" + "errorCode": "{{errorCode}}" } ] } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs index 0668a51b54b..763f9934fe8 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs @@ -1,12 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs index f02b83d1da2..760f777c2ba 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "maskedEmail": "{{maskedEmail}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs index 51c3caef0bb..345a4a7a017 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs @@ -1,11 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTP.yml b/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTP.yml index 45efc77718b..3f061e8a6b0 100644 --- a/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTP.yml +++ b/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTP.yml @@ -2,6 +2,7 @@ createSendOTP: Resident_SendOTP_All_Valid_Smoke: endPoint: /resident/v1/req/otp role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/SendOTP/createSendOTP outputTemplate: resident/SendOTP/createSendOTPResult diff --git a/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTPResult.hbs b/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTPResult.hbs index 555ca559a54..763f9934fe8 100644 --- a/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/resident/SendOTPUIN/createSendOTPResult.hbs @@ -1,12 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpForContactDet/SendOtpForContactDetResult.hbs b/automationtests/src/main/resources/resident/SendOtpForContactDet/SendOtpForContactDetResult.hbs index 2a4e1c8210a..e525d39ddda 100644 --- a/automationtests/src/main/resources/resident/SendOtpForContactDet/SendOtpForContactDetResult.hbs +++ b/automationtests/src/main/resources/resident/SendOtpForContactDet/SendOtpForContactDetResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.resident.contact.details.send.otp.id", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs b/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs index 1532d0be00a..345a4a7a017 100644 --- a/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs +++ b/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs @@ -1,12 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "maskedMobile": "{{maskedMobile}}", - "maskedEmail": "$IGNORE$" - }, - "errors": "$IGNORE$" + "maskedMobile": "{{maskedMobile}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpForVid/createSendOTPResult.hbs b/automationtests/src/main/resources/resident/SendOtpForVid/createSendOTPResult.hbs index 0668a51b54b..763f9934fe8 100644 --- a/automationtests/src/main/resources/resident/SendOtpForVid/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/resident/SendOtpForVid/createSendOTPResult.hbs @@ -1,12 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", - "transactionID": "$IGNORE$", - "metadata": "$IGNORE$", "response": { "maskedMobile": "{{maskedMobile}}", "maskedEmail": "{{maskedEmail}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdp.yml b/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdp.yml index 5246349e9e0..00c9c26dda8 100644 --- a/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdp.yml +++ b/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdp.yml @@ -2,6 +2,7 @@ SendOtpIdp: Resident_ESignet_SendOtpIdp_all_Valid_Smoke: endPoint: /v1/idp/authorization/send-otp role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/SendOtpIdp/SendOtpIdp outputTemplate: resident/SendOtpIdp/SendOtpIdpResult @@ -12,6 +13,4 @@ SendOtpIdp: "otpChannels": [{channel: "email"}] }' output: '{ - "maskedEmail": "$IGNORE$", - "maskedMobile": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdpResult.hbs b/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdpResult.hbs index 15af7dc7dd6..c823777f1e9 100644 --- a/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdpResult.hbs +++ b/automationtests/src/main/resources/resident/SendOtpIdp/SendOtpIdpResult.hbs @@ -1,11 +1,6 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responseTime": "$IGNORE$", "response": { - "transactionId": "$IGNORE$", "maskedEmail": "{{maskedEmail}}", "maskedMobile": "{{maskedMobile}}" - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserId.yml b/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserId.yml index 7ebb03b978e..a6066bb3278 100644 --- a/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserId.yml +++ b/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserId.yml @@ -77,8 +77,7 @@ SendOtpToUserId: "message": "Invalid Input Parameter- requesttime" } ], - "status": "Email Request submitted", - "message": "success" + "status": "Email Request submitted" }' Resident_SendOtpToUserId_uin_Invalid_userId_Neg: @@ -179,8 +178,7 @@ SendOtpToUserId: "message": "Invalid Input Parameter- userId" } ], - "status": "Email Request submitted", - "message": "success" + "status": "Email Request submitted" }' Resident_SendOtpToUserId_uin_Invalid_transactionID_Neg: @@ -275,8 +273,7 @@ SendOtpToUserId: "transactionId": "$TRANSACTIONID$" }' output: '{ - "status": "Email Request submitted", - "message": "success" + "status": "Email Request submitted" }' Resident_SendOtpToUserId_vid_Invalid_Requesttime_Neg: @@ -337,8 +334,7 @@ SendOtpToUserId: "message": "Invalid Input Parameter- requesttime" } ], - "status": "Email Request submitted", - "message": "success" + "status": "Email Request submitted" }' Resident_SendOtpToUserId_vid_Invalid_userId_Neg: @@ -439,8 +435,7 @@ SendOtpToUserId: "message": "Invalid Input Parameter- userId" } ], - "status": "Email Request submitted", - "message": "success" + "status": "Email Request submitted" }' Resident_SendOtpToUserId_vid_Invalid_transactionID_Neg: @@ -536,6 +531,5 @@ SendOtpToUserId: "transactionId": "$TRANSACTIONID$" }' output: '{ - "status": "Email Request submitted", - "message": "success" + "status": "Email Request submitted" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserIdResult.hbs b/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserIdResult.hbs index 0ae65b1b493..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserIdResult.hbs +++ b/automationtests/src/main/resources/resident/SendOtpToUserId/SendOtpToUserIdResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.contact.details.send.otp.id", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml b/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml index 744ff04c35f..8f5916782e5 100644 --- a/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml +++ b/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml @@ -16,5 +16,4 @@ SignJWT: "includeCertHash": false }' output: '{ - "jwtSignedData": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs b/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs index 9722a3b0abc..205dafa2b95 100644 --- a/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs +++ b/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs @@ -1,9 +1,5 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "jwtSignedData": "{{jwtSignedData}}", - "timestamp": "$IGNORE$" + "jwtSignedData": "{{jwtSignedData}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateData.yml b/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateData.yml index d4ab201db9f..88e2d95a414 100644 --- a/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateData.yml +++ b/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateData.yml @@ -2,6 +2,7 @@ TranslitrateData: Resident_TranslitrateData_uin_all_Valid_Smoke: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/TranslitrateData/TranslitrateDataResult @@ -18,6 +19,7 @@ TranslitrateData: Resident_TranslitrateData_vid_all_Valid_Smoke: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/TranslitrateData/TranslitrateDataResult @@ -34,6 +36,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Same_Lang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -55,6 +58,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Invalid_UserToken_Neg: endPoint: /resident/v1/transliteration/transliterate role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -76,6 +80,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Invalid_Token_Neg: endPoint: /resident/v1/transliteration/transliterate role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -97,6 +102,7 @@ TranslitrateData: Resident_TranslitrateData_StatusCode_Empty_Token_Neg: endPoint: /resident/v1/transliteration/transliterate role: + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -111,6 +117,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Invalid_FromLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -132,6 +139,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Missing_FromLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -153,6 +161,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Empty_FromLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -174,6 +183,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Invalid_ToLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -195,6 +205,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Missing_ToLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -216,6 +227,7 @@ TranslitrateData: Resident_TranslitrateData_uin_Empty_ToLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -237,6 +249,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Same_Lang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -258,6 +271,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Invalid_FromLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -279,6 +293,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Missing_FromLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -300,6 +315,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Empty_FromLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -321,6 +337,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Invalid_ToLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -342,6 +359,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Missing_ToLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error @@ -363,6 +381,7 @@ TranslitrateData: Resident_TranslitrateData_vid_Empty_ToLang_Neg: endPoint: /resident/v1/transliteration/transliterate role: residentNewVid + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/TranslitrateData/TranslitrateData outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateDataResult.hbs b/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateDataResult.hbs index 16f9d9b43c2..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateDataResult.hbs +++ b/automationtests/src/main/resources/resident/TranslitrateData/TranslitrateDataResult.hbs @@ -1,11 +1 @@ -{ - "id": "mosip.resident.transliteration.transliterate", - "version": "1.0", - "responsetime": "$IGNORE$", - "response": { - "from_field_value": "$IGNORE$", - "from_field_lang": "$IGNORE$", - "to_field_value": "$IGNORE$", - "to_field_lang": "$IGNORE$" - } -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatus.yml b/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatus.yml index f94124da2f4..ce9b0d5ecc8 100644 --- a/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatus.yml +++ b/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatus.yml @@ -9,8 +9,7 @@ UnPinStatus: "eventId": "$ID:GetServiceHistory_uin_all_Valid_Smoke_sid_eventId$" }' output: '{ - "status": "200", - "message": "SUCCESS" + "status": "200" }' Resident_UnPinStatus_vid_all_Valid_Smoke: @@ -23,8 +22,7 @@ UnPinStatus: "eventId": "$ID:GetServiceHistory_vid_all_Valid_Smoke_sid_eventId$" }' output: '{ - "status": "200", - "message": "SUCCESS" + "status": "200" }' Resident_UnPinStatus_uin_Invalid_Input_Neg: diff --git a/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatusResult.hbs b/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatusResult.hbs index 52e3713cc82..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatusResult.hbs +++ b/automationtests/src/main/resources/resident/UnPinStatus/UnPinStatusResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.resident.unpin.status", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs b/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs index b3ec94d40d5..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs +++ b/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.contact.details.update.id", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "$IGNORE$" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/UpdateUIN/UpdateUIN.yml b/automationtests/src/main/resources/resident/UpdateUIN/UpdateUIN.yml index a0ae8e462f1..1810abf3c6b 100644 --- a/automationtests/src/main/resources/resident/UpdateUIN/UpdateUIN.yml +++ b/automationtests/src/main/resources/resident/UpdateUIN/UpdateUIN.yml @@ -2,6 +2,7 @@ UpdateUIN: Resident_UpdateUIN_Valid_All_Smoke_Pos_sid: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/UpdateUIN/UpdateUinResult @@ -24,8 +25,6 @@ UpdateUIN: } }' output: '{ - "registrationId": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -36,6 +35,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_Otp_Empty_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -74,6 +74,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_Otp_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -112,6 +113,7 @@ UpdateUIN: Resident_UpdateUIN_Missing_Otp_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -150,6 +152,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_TrnxID_Empty_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -188,6 +191,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_TrnxID_Mismatch_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -226,6 +230,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_IndividualId_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -264,6 +269,7 @@ UpdateUIN: Resident_UpdateUIN_Missing_IndividualId_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -302,6 +308,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_Id_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -340,6 +347,7 @@ UpdateUIN: Resident_UpdateUIN_Missing_Id_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -378,6 +386,7 @@ UpdateUIN: Resident_UpdateUIN_Missing_Timestamp_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -416,6 +425,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_Timestamp_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -454,6 +464,7 @@ UpdateUIN: Resident_UpdateUIN_Invalid_Version_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error @@ -492,6 +503,7 @@ UpdateUIN: Resident_UpdateUIN_Missing_Version_Neg: endPoint: /resident/v1/req/update-uin role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/UpdateUIN/updateUIN outputTemplate: resident/error diff --git a/automationtests/src/main/resources/resident/UpdateUIN/UpdateUinResult.hbs b/automationtests/src/main/resources/resident/UpdateUIN/UpdateUinResult.hbs index 4ec92e7160c..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/UpdateUIN/UpdateUinResult.hbs +++ b/automationtests/src/main/resources/resident/UpdateUIN/UpdateUinResult.hbs @@ -1,11 +1 @@ -{ - "id": "mosip.resident.updateuin", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "registrationId": "{{registrationId}}", - "message": "{{message}}" - }, - "errors": null -} \ No newline at end of file +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNew.yml b/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNew.yml index b720e3309de..52b9b52bc0d 100644 --- a/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNew.yml +++ b/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNew.yml @@ -12,8 +12,7 @@ UpdateUINNew: "email": "$ID:AddIdentity_Esignet_Integ_smoke_Pos_EMAIL$" }' output: '{ - "status": "Success", - "message": "Notification has been sent to the provided contact detail(s)" + "status": "Success" }' Resident_UpdateUINNew_vid_all_Valid_Smoke: @@ -29,8 +28,7 @@ UpdateUINNew: "email": "$ID:AddIdentity_Esignet_Integ_Vid_smoke_Pos_EMAIL$" }' output: '{ - "status": "Success", - "message": "Notification has been sent to the provided contact detail(s)" + "status": "Success" }' Resident_UpdateUINNew_Invalid_User_Neg: @@ -88,8 +86,7 @@ UpdateUINNew: "email": "$ID:AddIdentity_Esignet_Integ_smoke_Pos_EMAIL$" }' output: '{ - "status": "Success", - "message": "Notification has been sent to the provided contact detail(s)" + "status": "Success" }' Resident_UpdateUINNew_Empty_TransactionID_Neg: @@ -273,8 +270,7 @@ UpdateUINNew: "email": "$ID:AddIdentity_Esignet_Integ_Vid_smoke_Pos_EMAIL$" }' output: '{ - "status": "Success", - "message": "Notification has been sent to the provided contact detail(s)" + "status": "Success" }' Resident_UpdateUINNew_vid_Empty_TransactionID_Neg: diff --git a/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNewResult.hbs b/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNewResult.hbs index a0e63664e70..3d65817bc68 100644 --- a/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNewResult.hbs +++ b/automationtests/src/main/resources/resident/UpdateUINNew/UpdateUINNewResult.hbs @@ -1,11 +1,5 @@ { - "id": "mosip.resident.updateuin", - "version": "1.0", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTP.yml b/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTP.yml index 426bd064b11..b2121a698d2 100644 --- a/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTP.yml +++ b/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTP.yml @@ -56,7 +56,7 @@ ValidateExpiredOTP: output: '{ "errors": [ { - "errorCode": "RES-SER-406", + "errorCode": "RES-SER-422", "message": "$IGNORE$" } ] @@ -77,7 +77,7 @@ ValidateExpiredOTP: output: '{ "errors": [ { - "errorCode": "RES-SER-406", + "errorCode": "RES-SER-422", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTPResult.hbs b/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTPResult.hbs deleted file mode 100644 index b61e5a2dbd0..00000000000 --- a/automationtests/src/main/resources/resident/ValidateExpiredOTP/ValidateExpiredOTPResult.hbs +++ /dev/null @@ -1,10 +0,0 @@ -{ - "id": "mosip.identity.auth.internal", - "version": "v1", - "responsetime": "$IGNORE$", - "response": { - "authStatus": {{authStatus}}, - "transactionId": "$IGNORE$", - "status": "{{status}}" - } -} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/ValidateOTP/ValidateOTPResult.hbs b/automationtests/src/main/resources/resident/ValidateOTP/ValidateOTPResult.hbs index 22e196eabfb..0fb038bb611 100644 --- a/automationtests/src/main/resources/resident/ValidateOTP/ValidateOTPResult.hbs +++ b/automationtests/src/main/resources/resident/ValidateOTP/ValidateOTPResult.hbs @@ -1,9 +1,5 @@ { - "id": "mosip.identity.auth.internal", - "version": "v1", - "responsetime": "$IGNORE$", "response": { - "authStatus": {{authStatus}}, - "transactionID": "$IGNORE$" + "authStatus": {{authStatus}} } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml b/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml index bfee10c6001..fa27228b734 100644 --- a/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml +++ b/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml @@ -1219,8 +1219,7 @@ ValidateWithUserIdOtp: "message": "success", "sendOtpResTemplate":"resident/SendOtpToUserId/SendOtpToUserIdResult" }, - "status": "success", - "message": "VALIDATION_SUCCESSFUL" + "status": "success" }' Resident_ValidateWithUserIdOtp_vid_all_Valid_Smoke: @@ -1248,6 +1247,5 @@ ValidateWithUserIdOtp: "message": "success", "sendOtpResTemplate":"resident/SendOtpToUserId/SendOtpToUserIdResult" }, - "status": "success", - "message": "VALIDATION_SUCCESSFUL" + "status": "success" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtpResult.hbs b/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtpResult.hbs index 38c1ff7a185..ca45b742b9e 100644 --- a/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtpResult.hbs +++ b/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtpResult.hbs @@ -1,10 +1,5 @@ { - "id": "mosip.resident.contact.details.update.id", - "version": "1.0", - "responsetime": "$IGNORE$", "response": { - "status": "{{status}}", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + "status": "{{status}}" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/error.hbs b/automationtests/src/main/resources/resident/error.hbs index 76ee450326e..f4bcb6bee67 100644 --- a/automationtests/src/main/resources/resident/error.hbs +++ b/automationtests/src/main/resources/resident/error.hbs @@ -1,16 +1,8 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "timestamp": "$IGNORE$", - "status": "$IGNORE$", - "metadata": "$IGNORE$", - "response": "$IGNORE$", "errors": [ {{#each errors}} { - "errorCode": "{{errorCode}}", - "message": "$IGNORE$" + "errorCode": "{{errorCode}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/testNgXmlFiles/residentApi.xml b/automationtests/testNgXmlFiles/residentApi.xml index 1f38b149127..239d40a35c2 100644 --- a/automationtests/testNgXmlFiles/residentApi.xml +++ b/automationtests/testNgXmlFiles/residentApi.xml @@ -113,6 +113,13 @@ + + + + + + - - - - - - From dffaf4e32c7856686f3cf59df4112b485529e85d Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 29 Aug 2023 13:03:46 +0530 Subject: [PATCH 091/204] MOSIP-28924 --- .../fw/util/AuditValidation.java | 136 ------------------ .../authentication/fw/util/AuthTestsUtil.java | 33 +---- .../fw/util/BiometricDataUtility.java | 19 +-- .../authentication/fw/util/DbConnection.java | 2 +- .../testrig/apirig/dbaccess/AuditDbRead.java | 62 -------- .../GenerateVID/createGenerateVIDResult.hbs | 1 - .../mobileId/SendOTP/createSendOTPResult.hbs | 2 +- 7 files changed, 7 insertions(+), 248 deletions(-) delete mode 100644 automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java delete mode 100644 automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java deleted file mode 100644 index 7196b7074f0..00000000000 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java +++ /dev/null @@ -1,136 +0,0 @@ -package io.mosip.testrig.apirig.authentication.fw.util; - -import java.io.File; -import java.io.IOException; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.regex.Pattern; - -import com.fasterxml.jackson.core.JsonParseException; -import com.fasterxml.jackson.databind.JsonMappingException; - -import io.mosip.testrig.apirig.admin.fw.util.AdminTestException; -import io.mosip.testrig.apirig.authentication.fw.dto.OutputValidationDto; -import io.mosip.testrig.apirig.global.utils.GlobalConstants; - -/** - * The class to handle audit log and auth transaction validation - * @author M1049813 - * - */ -public class AuditValidation { - - private static File auth_txn_file; - private static File audit_log_file; - - /** - * The method verify audit Transaction of IDA - * - * @param listOfFiles - * @param keywordToFind - * @return Map, Output Validation report - * @throws AdminTestException - * @throws IOException - * @throws JsonMappingException - * @throws JsonParseException - */ - public static Map> verifyAuditTxn(File[] listOfFiles, String keywordToFind) throws AdminTestException{ - auth_txn_file = FileUtil.getFileFromList(listOfFiles, keywordToFind); - Map exp = AuthTestsUtil.getPropertyAsMap(auth_txn_file.getAbsolutePath()); - Map act = DbConnection.getDataForQuery( - "select requested_entity_name,requested_entity_id,requested_entity_type,request_dtimes,response_dtimes,id,request_trn_id,auth_type_code,status_code,status_comment,lang_code,ref_id_type,ref_id,cr_dtimes from ida.auth_transaction where request_trn_id = '" - + exp.get("request_trn_id") + "' order by cr_dtimes desc limit 1", - "IDA"); - AuthTestsUtil.generateMappingDic(auth_txn_file.getAbsolutePath(), preconAuditKeywords(exp, act)); - return OutputValidationUtil.doJsonOutputValidation(act, exp, false, "Audit Transaction Validation", false); - } - - /** - * The method verify audit log of IDA - * - * @param listOfFiles - * @param keywordToFind - * @return Map, Output Validation report - * @throws AdminTestException - * @throws IOException - * @throws JsonMappingException - * @throws JsonParseException - */ - public static Map> verifyAuditLog(File[] listOfFiles, String keywordToFind) throws AdminTestException { - audit_log_file = FileUtil.getFileFromList(listOfFiles, keywordToFind); - Map exp = AuthTestsUtil.getPropertyAsMap(audit_log_file.getAbsolutePath()); - Map act = null; - if (FileUtil.verifyFilePresent(listOfFiles, "auth_transaction")) { - Map exp_auth_txn = AuthTestsUtil.getPropertyAsMap(auth_txn_file.getAbsolutePath()); - if (exp_auth_txn.containsKey("request_dtimes") && exp_auth_txn.containsKey("response_dtimes")) { - act = DbConnection - .getDataForQuery( - getAuditLogQuery(exp.get(GlobalConstants.APP_NAME), exp.get(GlobalConstants.MODULE_NAME), exp.get(GlobalConstants.REFID), - exp_auth_txn.get("request_dtimes"), exp_auth_txn.get("response_dtimes")), - GlobalConstants.AUDIT); - } else { - act = DbConnection.getDataForQuery( - getAuditLogQuery(exp.get(GlobalConstants.APP_NAME), exp.get(GlobalConstants.MODULE_NAME), exp.get(GlobalConstants.REFID)), GlobalConstants.AUDIT); - } - } else { - act = DbConnection.getDataForQuery( - getAuditLogQuery(exp.get(GlobalConstants.APP_NAME), exp.get(GlobalConstants.MODULE_NAME), exp.get(GlobalConstants.REFID)), GlobalConstants.AUDIT); - } - return OutputValidationUtil.doJsonOutputValidation(act, exp, false, "Audit Log Validation", false); - } - - /** - * The method to precondtion audit impl keywords - * - * @param exp, expected value as map - * @param act, actual value as map - * @return Map - */ - private static Map preconAuditKeywords(Map exp, Map act) { - for (Entry temp : exp.entrySet()) { - if (temp.getValue().contains("$FETCH$")) { - exp.put(temp.getKey(), act.get(temp.getKey())); - } else if (temp.getValue().contains("$") && temp.getValue().contains(":") - && temp.getValue().contains("audit.")) { - String[] arr = temp.getValue().replace("$", "").split(Pattern.quote(":")); - String value = arr[1]; - exp.put(temp.getKey(), - AuthTestsUtil.getValueFromPropertyFile(auth_txn_file.getAbsolutePath(), value)); - } - } - return exp; - } - - /** - * The method get audit log query with timestamp - * - * @param app_name - * @param module_name - * @param ref_id - * @param action_dtimes_minTime - * @param action_dtimes_maxTime - * @return String, SQL Query - */ - private static String getAuditLogQuery(String app_name, String module_name, String ref_id, String action_dtimes_minTime, - String action_dtimes_maxTime) { - return "select log_id,log_dtimes,log_desc,event_id,event_type,event_name,action_dtimes,host_name,host_ip,session_user_id,session_user_name,app_id,app_name,module_id,module_name,ref_id,ref_id_type,cr_by from audit.app_audit_log where app_name ='" + app_name + "' and module_name='" + module_name - + "' and ref_id ='" + ref_id + "' and action_dtimes >= timestamp '" + action_dtimes_minTime - + "'- interval '10 second' and action_dtimes <= timestamp '" + action_dtimes_maxTime - + "' + interval '10 second' order by log_dtimes limit 1"; - } - - /** - * The method get audit log query - * - * @param app_name - * @param module_name - * @param ref_id - * @return String, SQL Query - */ - private static String getAuditLogQuery(String app_name, String module_name, String ref_id) { - return "select log_id,log_dtimes,log_desc,event_id,event_type,event_name,action_dtimes,host_name,host_ip,session_user_id,session_user_name,app_id,app_name,module_id,module_name,ref_id,ref_id_type,cr_by from audit.app_audit_log where app_name ='" + app_name + "' and module_name='" + module_name - + "' and ref_id ='" + ref_id + "' order by log_dtimes limit 1"; - } - -} diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java index c83f0cda37e..7db4bede2ad 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java @@ -731,19 +731,7 @@ private static Properties getRunConfigData() { * @param otpMappingFieldName * @return String , OTP Value */ - public String getOtpValue(String inputFilePath, String mappingFileName, String otpMappingFieldName) { - String value = JsonPrecondtion.getValueFromJson(inputFilePath, mappingFileName, otpMappingFieldName); - if (value.contains(":")) { - if (proxy) - return "111111"; - String[] otpKeyword = value.split(":"); - String otpQuery = otpKeyword[0]; - String waitTime = otpKeyword[1]; - wait(Integer.parseInt(waitTime) * 1000); - return DbConnection.getDataForQuery(otpQuery, "KERNEL").get("otp"); - } else - return value; - } + /** * The method retrieve value from json @@ -1088,24 +1076,7 @@ public File getFile(File[] listOfFiles, String keywordToFind) { return null; } - /** - * The method will get otp value - * - * @param value - * @return OTP value - */ - public String getOtpValue(String value) { - if (value.contains(":")) { - if (proxy) - return "111111"; - String[] otpKeyword = value.split(":"); - String otpQuery = otpKeyword[0]; - String waitTime = otpKeyword[1]; - wait(Integer.parseInt(waitTime) * 1000); - return DbConnection.getDataForQuery(otpQuery, "KERNEL").get("otp"); - } else - return value; - } + /** * The method returns run config path diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java index 5f641e823d6..25151c62c43 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java @@ -136,24 +136,11 @@ private static String getSignedData(String identityDataBlock) { public static Map> allDeviceParam = new HashMap<>(); - public static void storeDeviceDetail(String id) { - if (!allDeviceParam.containsKey(id)) { - String deviceParams[] = id.split(":"); - Map deviceParam = getDataFromRegisteredDeviceMaster(deviceParams[0],deviceParams[1]); - deviceParam.putAll(getDataFromMosipDeviceService(deviceParams[0],deviceParams[2])); - allDeviceParam.put(id, deviceParam); - } - } - private static Map getDataFromRegisteredDeviceMaster(String id,String deviceId) { - String query = "select * from master.registered_device_master where provider_id='" + id + "'"+" and device_id='"+deviceId+"'"; - return DbConnection.getDataForQuery(query, "MASTER"); - } - private static Map getDataFromMosipDeviceService(String id,String model) { - String query = "select * from master.mosip_device_service where dprovider_id='" + id + "'"+" and model='"+model+"'"; - return DbConnection.getDataForQuery(query, "MASTER"); - } + + + } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/DbConnection.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/DbConnection.java index f6d3b2aabb4..177c3087c97 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/DbConnection.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/DbConnection.java @@ -43,7 +43,7 @@ public class DbConnection { public static void main(String[] arg) { - DBCONNECTION_LOGGER.info(getDataForQuery("update reg_center_machine_device set device_id = '3000022' where regcntr_id = '10003' and device_id='3000033'","MASTER")); + } /** * Execute query to get generated otp value diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java deleted file mode 100644 index 9ba85d3af20..00000000000 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java +++ /dev/null @@ -1,62 +0,0 @@ -package io.mosip.testrig.apirig.dbaccess; - -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.util.Properties; - -import org.apache.log4j.Logger; -import org.hibernate.HibernateException; -import org.hibernate.Session; -import org.hibernate.SessionFactory; -import org.hibernate.cfg.Configuration; -import org.testng.Assert; - -import io.mosip.testrig.apirig.admin.fw.util.AdminTestUtil; -import io.mosip.testrig.apirig.testrunner.MosipTestRunner; - -public class AuditDbRead { - - public static SessionFactory factory; - static Session session; - private static Logger logger = Logger.getLogger(AuditDbRead.class); - public static String env = System.getProperty("env.user"); - - public static Session getDataBaseConnection(String dbName) { - String dbConfigXml = MosipTestRunner.getGlobalResourcePath()+"/dbFiles/dbConfig.xml"; - String dbPropsPath = MosipTestRunner.getGlobalResourcePath()+"/dbFiles/dbProps"+env+".properties"; - FileInputStream inputStream = null; - try { - inputStream = new FileInputStream(new File(dbPropsPath)); - Properties dbProps = new Properties(); - dbProps.load(inputStream); - Configuration config = new Configuration(); - config.setProperty("hibernate.connection.driver_class", dbProps.getProperty("driver_class")); - config.setProperty("hibernate.connection.url", dbProps.getProperty(dbName+"_url")); - config.setProperty("hibernate.connection.username", dbProps.getProperty(dbName+"_username")); - config.setProperty("hibernate.connection.password", dbProps.getProperty(dbName+"_password")); - config.setProperty("hibernate.default_schema", dbProps.getProperty(dbName+"_default_schema")); - config.setProperty("hibernate.connection.pool_size", dbProps.getProperty("pool_size")); - config.setProperty("hibernate.dialect", dbProps.getProperty("dialect")); - config.setProperty("hibernate.show_sql", dbProps.getProperty("show_sql")); - config.setProperty("hibernate.current_session_context_class", dbProps.getProperty("current_session_context_class")); - config.addFile(new File(dbConfigXml)); - factory = config.buildSessionFactory(); - session = factory.getCurrentSession(); - } - catch (HibernateException | IOException e) { - logger.info("Exception in Database Connection with following message: "); - logger.info(e.getMessage()); - logger.error(e.getMessage()); - Assert.assertTrue(false, "Exception in creating the sessionFactory"); - }catch (NullPointerException e) { - Assert.assertTrue(false, "Exception in getting the session"); - }finally { - AdminTestUtil.closeInputStream(inputStream); - } - session.beginTransaction(); - logger.info("==========session begins============="); - return session; - } - -} diff --git a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs index 97c855c020c..78c1714954b 100644 --- a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs @@ -3,7 +3,6 @@ "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { - "vid": "{{vid}}", "message": "{{message}}" }, "errors": [] diff --git a/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs index 7e8707fc0db..0d2979854c7 100644 --- a/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs @@ -1,6 +1,6 @@ { "id": "mosip.identity.otp.internal", "response": { - "maskedMobile": "{{maskedMobile}}" + "maskedMobile": "$IGNORE$" } } \ No newline at end of file From bbdba9bda8b9aae0845e63343c5ac876db44c7ff Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 29 Aug 2023 15:48:49 +0530 Subject: [PATCH 092/204] MOSIP-29082 --- .../resources/resident/AuthLock/createAuthLock.yml | 3 +-- .../RequestCredentials/ReqCredential.yml | 13 ++++++++----- .../resident/GenerateVID/ReGenerateVID.yml | 6 ++---- .../GenerateVID/createGenerateVIDNewResult.hbs | 1 - .../resident/GetNotifications/GetNotifications.yml | 10 ++-------- .../GetRegistrationCenterWorkingDays.yml | 3 +-- .../GetRequestCardVid/GetRequestCardVid.yml | 3 +-- .../resident/RevokeVIDNew/CreateRevokeVIDNew.yml | 12 +++--------- .../resources/resident/SignJWT/SignJWTResult.hbs | 6 +----- 9 files changed, 19 insertions(+), 38 deletions(-) diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml index 678b334dc09..af7d6551426 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml @@ -1170,8 +1170,7 @@ AuthLock: output: '{ "errors": [ { - "errorCode": "$IGNORE$", - "message": "$IGNORE$" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml index 4bd264295fa..a82d271fe5b 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -426,7 +426,7 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-410", + "errorCode": "RES-SER-412", "message": "$IGNORE$" } ], @@ -463,8 +463,7 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" + "errorCode": "RES-SER-412" } ], "sendOtpResp":{ @@ -1277,7 +1276,7 @@ RequestCredentials: restMethod: post checkErrorsOnlyInResponse: true inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential - outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult + outputTemplate: resident/error input: '{ "transactionID": "$TRANSACTIONID$", "individualId": "$ID:AddIdentity_Positive_smoke_Pos_UIN$", @@ -1296,7 +1295,11 @@ RequestCredentials: } }' output: '{ - + "errors": [ + { + "errorCode": "RES-SER-410" + } + ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", diff --git a/automationtests/src/main/resources/resident/GenerateVID/ReGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/ReGenerateVID.yml index 26f13a1c7de..355340ff287 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/ReGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/ReGenerateVID.yml @@ -2,6 +2,7 @@ ReGenerateVID: Resident_ReGenerateVID_All_Valid_Smoke_Perpetual_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult @@ -24,8 +25,6 @@ ReGenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", @@ -35,6 +34,7 @@ ReGenerateVID: Resident_ReGenerateVID_All_Valid_Smoke_Temp_VID_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult @@ -57,8 +57,6 @@ ReGenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs index 1ec37c80830..2e5ab7d5d79 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs @@ -1,6 +1,5 @@ { "response": { - "vid": "{{vid}}", "maskedPhone": "{{maskedPhone}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml b/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml index 1134e8813d4..6bfe1e5e327 100644 --- a/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml +++ b/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml @@ -89,25 +89,19 @@ GetNotifications: ] }' - Resident_GetNotifications_vid_1_Invalid_PageNo_Neg: + Resident_GetNotifications_vid_1_Invalid_PageNo_Pos: endPoint: /resident/v1/notifications/{langCode}?pageStart={pageStart}&pageFetch={pageFetch} role: residentNewVid checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetNotifications/GetNotifications - outputTemplate: resident/error + outputTemplate: resident/GetNotifications/GetNotificationsResult input: '{ "langCode": "$1STLANG$", "pageStart":"11", "pageFetch":"2" }' output: '{ - "errors": [ - { - "errorCode": "RES-SER-410", - "message": "$IGNORE$" - } - ] }' diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml index c0b97e6ca6b..13df247b0ab 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml @@ -77,12 +77,11 @@ GetRegistrationCenterWorkingDays: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident checkErrorsOnlyInResponse: true - templateFields: ["langCode"] restMethod: get inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/error input: '{ - "langCode": "eng", + "langCode": "$1STLANG$", "registrationCenterID": "" }' output: "404" diff --git a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml index 09bbb50f4fe..7f0c19b29ad 100644 --- a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml +++ b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml @@ -62,8 +62,7 @@ GetRequestCardVid: output: '{ "errors": [ { - "errorCode": "RES-SER-454", - "message": "$IGNORE$" + "errorCode": "RES-SER-454" } ] }' diff --git a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml index efe1eed774f..2df946a782f 100644 --- a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml +++ b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml @@ -88,13 +88,13 @@ RevokeVIDNew: } ] }' - Resident_RevokeVIDNew_Using_Vid_Valid_Neg: + Resident_RevokeVIDNew_Using_Vid_Valid_Smoke: endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_1_Esignet_Integ_Valid_Smoke_sid_vid$ role: residentNewVid checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNew - outputTemplate: resident/error + outputTemplate: resident/RevokeVIDNew/CreateRevokeVIDNewResult input: '{ "transactionID": "$TRANSACTIONID$", "requesttime": "$TIMESTAMP$", @@ -103,12 +103,6 @@ RevokeVIDNew: "vidStatus": "Revoked" }' output: '{ - "errors": [ - { - "errorCode": "RES-SER-406", - "message": "Exception while creating VID" - } - ] }' Resident_RevokeVIDNew_uin_Using_Vid_Invalid_User_Neg: @@ -128,7 +122,7 @@ RevokeVIDNew: output: '{ "errors": [ { - "errorCode": "RES-SER-407", + "errorCode": "RES-SER-454", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs b/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs index 205dafa2b95..9e26dfeeb6e 100644 --- a/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs +++ b/automationtests/src/main/resources/resident/SignJWT/SignJWTResult.hbs @@ -1,5 +1 @@ -{ - "response": { - "jwtSignedData": "{{jwtSignedData}}" - } -} \ No newline at end of file +{} \ No newline at end of file From 6d63d65ca74b553c7e19c0274f7106b4a6cc4f55 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 29 Aug 2023 16:15:03 +0530 Subject: [PATCH 093/204] MOSIP-29115 --- .../apirig/dbaccess/AuditDBManager.java | 57 +++++++++++++------ 1 file changed, 40 insertions(+), 17 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDBManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDBManager.java index 71388a1fcca..8b2cb548488 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDBManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDBManager.java @@ -6,6 +6,7 @@ import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.sql.Statement; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -27,6 +28,8 @@ public class AuditDBManager extends AdminTestUtil { private static Map records; private static List> allRecords; public static String env = System.getProperty("env.user"); + public static Map sessionFactoryMapS = Collections + .synchronizedMap(new HashMap()); /** * Execute query to get generated otp value @@ -69,13 +72,6 @@ public void execute(Connection connection) throws SQLException { return record; } - - public static void closeDataBaseConnection(Session session) { - if (session != null) { - DBCONNECTION_LOGGER.info("==========session closed============="); - session.close(); - } - } public static void executeQueryAndDeleteRecord(String moduleName, String deleteQuery) { Session session = null; @@ -105,12 +101,33 @@ public void execute(Connection connection) throws SQLException { } private static Session getDataBaseConnection(String dbName) { - SessionFactory factory = null; Session session = null; - String dbConfigXml = MosipTestRunner.getGlobalResourcePath() + "/dbFiles/dbConfig.xml"; - String dbschema=ConfigManager.getValueForKey("audit_db_schema"); + SessionFactory sessionFactory = sessionFactoryMapS.get(dbName); + if (sessionFactory == null) { + try { + sessionFactory = getDataBaseConnectionSessionFactory(dbName); + sessionFactoryMapS.put(dbName, sessionFactory); + } catch (HibernateException e) { + DBCONNECTION_LOGGER.error("Exception in Database Connection with following message: " + e.getMessage()); + } catch (NullPointerException e) { + Assert.assertTrue(false, "Exception in getting the SessionFactory for DB Schema : " + dbName ); + } + } + if (sessionFactory != null) { + session = sessionFactory.getCurrentSession(); + session.beginTransaction(); + DBCONNECTION_LOGGER.info("Session begined with Schema : " + dbName); + } + return session; + } + + private static SessionFactory getDataBaseConnectionSessionFactory(String dbName) { + SessionFactory factory = null; + String dbschema = ConfigManager.getValueForKey("audit_db_schema"); + if(dbName.equalsIgnoreCase("partner")) dbschema=ConfigManager.getValueForKey("ida_db_schema"); + try { Configuration config = new Configuration(); config.setProperty("hibernate.connection.driver_class", propsKernel.getProperty("driver_class")); @@ -126,16 +143,22 @@ private static Session getDataBaseConnection(String dbName) { config.setProperty("hibernate.show_sql", propsKernel.getProperty("show_sql")); config.setProperty("hibernate.current_session_context_class", propsKernel.getProperty("current_session_context_class")); - config.addFile(new File(dbConfigXml)); - factory = config.buildSessionFactory(); - session = factory.getCurrentSession(); - session.beginTransaction(); - DBCONNECTION_LOGGER.info("==========session begins============="); + config.addFile(new File(MosipTestRunner.getGlobalResourcePath() + "/dbFiles/dbConfig.xml")); + factory = config.buildSessionFactory(); } catch (HibernateException e) { DBCONNECTION_LOGGER.error("Exception in Database Connection with following message: " + e.getMessage()); } catch (NullPointerException e) { - Assert.assertTrue(false, "Exception in getting the session"); + Assert.assertTrue(false, "Exception in getting the SessionFactory for DB Schema : " + dbschema ); } - return session; + return factory; } + + + public static void closeDataBaseConnection(Session session) { + if (session != null) { + DBCONNECTION_LOGGER.info("Session closed"); + session.close(); + } + } + } From 01c4a91cf6519cbae850978d31e904bc1de1a3be Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 29 Aug 2023 17:39:52 +0530 Subject: [PATCH 094/204] MOSIP-29082 --- .../resources/resident/RidCheckStatus/createRidCheckStatus.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml index 0a89e6ef08a..e8ad492f8e7 100644 --- a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml +++ b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml @@ -13,6 +13,7 @@ RidCheckStatus: "requesttime": "$TIMESTAMP$" }' output: '{ + "ridStatus": "PROCESSED" }' Resident_RidCheckStatus_Missing_InputParameter_individualId: endPoint: /resident/v1/rid/check-status From 5bf2ae8c8d2dfffca32ce16c6876eaf71f23d4f8 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 29 Aug 2023 17:54:59 +0530 Subject: [PATCH 095/204] MOSIP-28924 --- .../CredentialCheckStatus/CredentialCheckStatus.yml | 8 ++++++-- .../RequestCredentials/ReqCredential.yml | 12 +++++++++--- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml index 0fb41596ac0..47eae90591f 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/CredentialCheckStatus/CredentialCheckStatus.yml @@ -34,5 +34,9 @@ CredentialsStatus: "requestId": "$er45" }' output: '{ - "statusCode": "ISSUED" -}' + "errors": [ + { + "errorCode": "RES-SER-29" + } + ] +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml index 10e5da1b4d0..33e38f3d6e9 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -2,6 +2,7 @@ RequestCredentials: MobileId_RequestCredentials__All_Valid_Smoke_sid: endPoint: /residentmobileapp/credentialshare/request role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult @@ -30,6 +31,7 @@ RequestCredentials: endPoint: /residentmobileapp/credentialshare/request role: resident restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult input: '{ @@ -139,7 +141,7 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-410" + "errorCode": "RES-SER-412" } ], "sendOtpResp":{ @@ -153,7 +155,7 @@ RequestCredentials: role: resident restMethod: post inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential - outputTemplate: mobileId/CredentialIssuance/RequestCredentials/ReqCredentialResult + outputTemplate: mobileId/error input: '{ "transactionID": "$TRANSACTIONID$", "individualId": "$hfg56", @@ -169,7 +171,11 @@ RequestCredentials: } }' output: '{ - "id": "$IGNORE$", + "errors": [ + { + "errorCode": "RES-SER-412" + } + ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" From aff9e19a766b0a625c70f473ef815634c834966a Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 29 Aug 2023 18:26:50 +0530 Subject: [PATCH 096/204] MOSIP-28924 --- .../AidGetIndividualId/AidGetIndividualId.yml | 27 ++++++------------- .../mobileId/AuthLock/createAuthLock.yml | 8 ++++-- .../AuthLock/createAuthLockResult.hbs | 9 ------- .../mobileId/AuthUnLock/createAuthUnLock.yml | 6 +++-- .../AuthUnLock/createAuthUnLockResult.hbs | 10 +------ .../GenerateVID/createGenerateVID.yml | 15 +++++------ .../mobileId/SendOTP/createSendOTPResult.hbs | 4 --- .../SendOTPUIN/individualIdOtpResult.hbs | 5 ---- 8 files changed, 25 insertions(+), 59 deletions(-) diff --git a/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml b/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml index 176db703232..79a666aeb8f 100644 --- a/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml +++ b/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml @@ -2,6 +2,7 @@ AidGetIndividualId: MobileId_AidGetIndividualId_Getting_With_Valid_UIN_All: endPoint: /residentmobileapp/aid/get-individual-id role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AidGetIndividualId/aidGetIndividualId outputTemplate: mobileId/AidGetIndividualId/aidGetIndividualIdResult @@ -19,9 +20,7 @@ AidGetIndividualId: output: '{ "aidStatus": "PROCESSED", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult" } }' @@ -50,9 +49,7 @@ AidGetIndividualId: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult" } }' @@ -76,14 +73,11 @@ AidGetIndividualId: output: '{ "errors": [ { - "errorCode": "RES-SER-422", - "errorMessage": "OTP is invalid" + "errorCode": "RES-SER-422" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult" } }' @@ -107,9 +101,7 @@ AidGetIndividualId: output: '{ "aidStatus": "PROCESSED", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult" } }' @@ -133,13 +125,10 @@ AidGetIndividualId: output: '{ "errors": [ { - "errorCode": "RES-SER-457", - "errorMessage": "Invalid Input Parameter- individualId" + "errorCode": "RES-SER-457" } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" + "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult" } }' diff --git a/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml index f6e0c43b3b5..2ac1736182e 100644 --- a/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/mobileId/AuthLock/createAuthLock.yml @@ -2,6 +2,7 @@ AuthLock: MobileId_AuthLock_Valid_UIN_All: endPoint: /residentmobileapp/req/auth/lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthLock/createAuthLock outputTemplate: mobileId/AuthLock/createAuthLockResult @@ -21,7 +22,6 @@ AuthLock: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } @@ -29,6 +29,7 @@ AuthLock: MobileId_AuthLock_InValid_Otp_All: endPoint: /residentmobileapp/req/auth/lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthLock/createAuthLock outputTemplate: mobileId/error @@ -60,6 +61,7 @@ AuthLock: MobileId_AuthLock_with_invalidUIN_Valid_Otp_sid: endPoint: /residentmobileapp/req/auth/lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthLock/createAuthLock outputTemplate: mobileId/error @@ -91,6 +93,7 @@ AuthLock: MobileId_AuthLock_Valid_VID_All: endPoint: /residentmobileapp/req/auth/lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthLock/createAuthLock outputTemplate: mobileId/AuthLock/createAuthLockResult @@ -110,7 +113,6 @@ AuthLock: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } @@ -118,6 +120,7 @@ AuthLock: MobileId_AuthLock_with_invalidVID_Valid_Otp: endPoint: /residentmobileapp/req/auth/lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthLock/createAuthLock outputTemplate: mobileId/error @@ -149,6 +152,7 @@ AuthLock: MobileId_AuthLock_invalidVID_Valid_Otp: endPoint: /residentmobileapp/req/auth/lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthLock/createAuthLock outputTemplate: mobileId/error diff --git a/automationtests/src/main/resources/mobileId/AuthLock/createAuthLockResult.hbs b/automationtests/src/main/resources/mobileId/AuthLock/createAuthLockResult.hbs index 2dfc65607e0..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/mobileId/AuthLock/createAuthLockResult.hbs +++ b/automationtests/src/main/resources/mobileId/AuthLock/createAuthLockResult.hbs @@ -1,11 +1,2 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "status": "$IGNORE$", - "message": "{{message}}" - }, - "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml index febab4b55ef..b5e4022d8fa 100644 --- a/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLock.yml @@ -2,6 +2,7 @@ AuthUnlock: MobileId_AuthUnLock_Valid_UIN_All: endPoint: /residentmobileapp/req/auth/unlock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthUnLock/createAuthUnLock outputTemplate: mobileId/AuthUnLock/createAuthUnLockResult @@ -22,7 +23,6 @@ AuthUnlock: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } @@ -30,6 +30,7 @@ AuthUnlock: MobileId_AuthUnLock_Valid_UIN_With_VID_All: endPoint: /residentmobileapp/req/auth/unlock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthUnLock/createAuthUnLock outputTemplate: mobileId/AuthUnLock/createAuthUnLockResult @@ -50,7 +51,6 @@ AuthUnlock: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } @@ -58,6 +58,7 @@ AuthUnlock: MobileId_AuthUnLock_With_InValid_OTP_All: endPoint: /residentmobileapp/req/auth/unlock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthUnLock/createAuthUnLock outputTemplate: mobileId/error @@ -90,6 +91,7 @@ AuthUnlock: MobileId_AuthUnLock_InValid_OTP_With_VID_All: endPoint: /residentmobileapp/req/auth/unlock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AuthUnLock/createAuthUnLock outputTemplate: mobileId/error diff --git a/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLockResult.hbs b/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLockResult.hbs index 2dfc65607e0..0e0dcd235c4 100644 --- a/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLockResult.hbs +++ b/automationtests/src/main/resources/mobileId/AuthUnLock/createAuthUnLockResult.hbs @@ -1,11 +1,3 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "status": "$IGNORE$", - "message": "{{message}}" - }, - "errors": "$IGNORE$" + } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml index 9f586645196..a7dd28badb7 100644 --- a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml @@ -2,6 +2,7 @@ GenerateVID: MobileId_Generate_Perpetual_VID_Valid_Smoke_sid: endPoint: /residentmobileapp/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/GenerateVID/createGenerateVID outputTemplate: mobileId/GenerateVID/createGenerateVIDResult @@ -21,15 +22,14 @@ GenerateVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_Generate_Perpetual_VID_InValid_Otp_sid: endPoint: /residentmobileapp/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/GenerateVID/createGenerateVID outputTemplate: mobileId/error @@ -55,13 +55,13 @@ GenerateVID: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_Generate_Perpetual_VID_with_InvalidUIN_Valid_Otp_sid: endPoint: /residentmobileapp/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/GenerateVID/createGenerateVID outputTemplate: mobileId/error @@ -87,7 +87,6 @@ GenerateVID: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -95,6 +94,7 @@ GenerateVID: MobileId_Generate_Temporary_VID_Valid_Smoke_sid: endPoint: /residentmobileapp/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/GenerateVID/createGenerateVID outputTemplate: mobileId/GenerateVID/createGenerateVIDResult @@ -114,9 +114,7 @@ GenerateVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -124,6 +122,7 @@ GenerateVID: MobileId_Generate_Perpetual_VID_Invalid_TransactionId_Neg: endPoint: /residentmobileapp/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/GenerateVID/createGenerateVID outputTemplate: mobileId/error @@ -149,7 +148,6 @@ GenerateVID: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -157,6 +155,7 @@ GenerateVID: MobileId_Generate_Perpetual_VID_Binding_Valid_Smoke_sid: endPoint: /residentmobileapp/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/GenerateVID/createGenerateVID outputTemplate: mobileId/GenerateVID/createGenerateVIDResult @@ -176,9 +175,7 @@ GenerateVID: } }' output: '{ - "message": "Notification has been sent to the provided contact detail(s)", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs index 0d2979854c7..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/mobileId/SendOTP/createSendOTPResult.hbs @@ -1,6 +1,2 @@ { - "id": "mosip.identity.otp.internal", - "response": { - "maskedMobile": "$IGNORE$" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs b/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs index 257f951c523..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs +++ b/automationtests/src/main/resources/mobileId/SendOTPUIN/individualIdOtpResult.hbs @@ -1,7 +1,2 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", - "response": { - "maskedMobile": "{{maskedMobile}}" - } } \ No newline at end of file From 731b59d82008d756520a036e5f7eced16c9e2cd8 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 29 Aug 2023 19:11:23 +0530 Subject: [PATCH 097/204] MOSIP-28924 --- .../mobileId/AidGetIndividualId/AidGetIndividualId.yml | 4 ++++ .../RequestCredentials/ReqCredential.yml | 10 ++++------ .../mobileId/GenerateVID/createGenerateVIDResult.hbs | 7 ------- .../resources/mobileId/SendOTPUIN/createSendOTP.yml | 3 +-- 4 files changed, 9 insertions(+), 15 deletions(-) diff --git a/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml b/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml index 79a666aeb8f..577ff7c3ec8 100644 --- a/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml +++ b/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml @@ -27,6 +27,7 @@ AidGetIndividualId: MobileId_AidGetIndividualId_Getting_With_Invalid_AID_Neg: endPoint: /residentmobileapp/aid/get-individual-id role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AidGetIndividualId/aidGetIndividualId outputTemplate: mobileId/error @@ -56,6 +57,7 @@ AidGetIndividualId: MobileId_AidGetIndividualId_Getting_With_Invalid_Otp_Neg: endPoint: /residentmobileapp/aid/get-individual-id role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AidGetIndividualId/aidGetIndividualId outputTemplate: mobileId/error @@ -84,6 +86,7 @@ AidGetIndividualId: MobileId_AidGetIndividualId_Getting_With_Valid_Otp_All: endPoint: /residentmobileapp/aid/get-individual-id role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AidGetIndividualId/aidGetIndividualId outputTemplate: mobileId/AidGetIndividualId/aidGetIndividualIdResult @@ -108,6 +111,7 @@ AidGetIndividualId: MobileId_AidGetIndividualId_Getting_With_Invalid_lenght_Of_AID_Neg: endPoint: /residentmobileapp/aid/get-individual-id role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/AidGetIndividualId/aidGetIndividualId outputTemplate: mobileId/error diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml index 33e38f3d6e9..164914b420b 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -23,7 +23,6 @@ RequestCredentials: output: '{ "id": "$IGNORE$", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -51,13 +50,13 @@ RequestCredentials: output: '{ "id": "$IGNORE$", "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_RequestCredentials_InValid_Otp_UIN_sid: endPoint: /residentmobileapp/credentialshare/request role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: mobileId/error @@ -82,13 +81,13 @@ RequestCredentials: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' MobileId_RequestCredentials_InValid_TransactionId_sid: endPoint: /residentmobileapp/credentialshare/request role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: mobileId/error @@ -113,7 +112,6 @@ RequestCredentials: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -121,6 +119,7 @@ RequestCredentials: MobileId_RequestCredentials_InValid_UIN_sid: endPoint: /residentmobileapp/credentialshare/request role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: mobileId/error @@ -145,7 +144,6 @@ RequestCredentials: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' @@ -153,6 +151,7 @@ RequestCredentials: MobileId_RequestCredentials_Invalid_VID_sid_Neg: endPoint: /residentmobileapp/credentialshare/request role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: mobileId/error @@ -177,7 +176,6 @@ RequestCredentials: } ], "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs index 78c1714954b..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVIDResult.hbs @@ -1,9 +1,2 @@ { - "id": "mosip.resident.vid", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "response": { - "message": "{{message}}" - }, - "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/mobileId/SendOTPUIN/createSendOTP.yml b/automationtests/src/main/resources/mobileId/SendOTPUIN/createSendOTP.yml index a366efa6bf3..0b2a2d703b6 100644 --- a/automationtests/src/main/resources/mobileId/SendOTPUIN/createSendOTP.yml +++ b/automationtests/src/main/resources/mobileId/SendOTPUIN/createSendOTP.yml @@ -2,6 +2,7 @@ individualOTP: MobileId_individualOTP_All_Valid_Smoke: endPoint: /residentmobileapp/req/individualId/otp role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: mobileId/SendOTPUIN/individualIdOtp outputTemplate: mobileId/SendOTPUIN/individualIdOtpResult @@ -10,6 +11,4 @@ individualOTP: "aid": "$ID:AddIdentity_withValidParameters_smoke_Pos_RID$" }' output: '{ - "maskedMobile": "XXXXXX3210", - "maskedEmail": "XXsXXeXXaXXoXXtXXn@gmail.com" }' \ No newline at end of file From 8694bedd4e0f70906d437dab3f336f0ad43ee0ec Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 29 Aug 2023 20:13:15 +0530 Subject: [PATCH 098/204] MOSIP-29086 --- .../DeviceDetailsFilter.yml | 2 +- .../DeviceSubTypeFilter.yml | 2 +- .../DeviceTypeFilter/DeviceTypeFilter.yml | 2 +- .../PartnerApiKeyRequestFilter.yml | 2 +- .../PartnerFilter/PartnerFilter.yml | 2 +- .../ServiceToFilterSBI/ServiceToFilterSBI.yml | 2 +- .../partner/GetPartners/GetPartners.yml | 1 + .../GetPartnersPolicy/GetPartnersPolicy.yml | 4 +-- .../PartnerSearch/PartnerSearchResult.hbs | 11 ++++++++ .../partner/PartnerSearch/partnerSearch.yml | 1 + .../createSearchSecureBiometric.yml | 12 ++------- .../RequestAPIKey/RequestAPIKey.yml | 2 +- .../create/CreateDeviceDetail.yml | 11 ++++---- .../create/createDeviceDetailResult.hbs | 3 --- .../update/UpdateDeviceDetail.yml | 4 +-- .../partner/policy/Search/SearchPolicy.yml | 24 ++++++++--------- .../policy/Search/searchPolicyResult.hbs | 26 ++----------------- 17 files changed, 45 insertions(+), 66 deletions(-) diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml index 24cad442d73..d6dfe5304c5 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml @@ -99,7 +99,7 @@ DeviceDetailsFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", + "errorCode": "PMS-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml index b37ef876fb5..9364e3dff55 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml @@ -119,7 +119,7 @@ DeviceSubTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", + "errorCode": "PMS-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml index 284c77a4d26..8ecfe6bdc10 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml @@ -109,7 +109,7 @@ DeviceTypeFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", + "errorCode": "PMS-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml index dffe107af2e..1aec35b56db 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerApiKeyRequestFilter/PartnerApiKeyRequestFilter.yml @@ -104,7 +104,7 @@ PartnerApiKeyRequestFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", + "errorCode": "PMS-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml index e6d0ddc0d3c..1499b69a6b1 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml @@ -83,7 +83,7 @@ PartnerFilter: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", + "errorCode": "PMS-MSD-317" } ] }' diff --git a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml index 308943b8ee6..e2aca4c4dc6 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml @@ -116,7 +116,7 @@ ServiceToFilterSBI: output: '{ "errors": [ { - "errorCode": "PMS-MSD-317", + "errorCode": "PMS-MSD-317" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml b/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml index 19d9ff88aab..d5bcbc05e46 100644 --- a/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml +++ b/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml @@ -40,6 +40,7 @@ GetPartners: Partner_PrintPartener_ByPartnerType_allValid_smoke: endPoint: /v1/partnermanager/partners/new?partnerType=Print_Partner role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetPartners/getPartners outputTemplate: partner/GetPartners/getPartnersResult diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml index dbbd8ebfc3d..07f1045e567 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml @@ -14,8 +14,8 @@ GetPartnersPolicy: output: '{ "policyGroupId": "mpolicygroup-default-auth", "policyGroupName": "mpolicygroup-default-auth", - "policyId": "mpolicy-default-auth", - "policyName": "mpolicy-default-auth", + "policyId": "$IGNORE$", + "policyName": "$IGNORE$", "status": "PUBLISHED" }' diff --git a/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs b/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs index 7a73a41bfdf..357b31a3ab1 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs +++ b/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs @@ -1,2 +1,13 @@ { + + "data": [ + {{#each data}} + { + "isActive": "{{isActive}}" + } + {{#unless @last}},{{/unless}} + {{/each}} + ] + + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml index 1fbd9372135..a3062a32cb5 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml +++ b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml @@ -280,6 +280,7 @@ createSearchPartner: Partner_SearchPartner_columnname_address_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/search/searchPartner outputTemplate: partner/search/searchPartnerResult diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml index 99838b046cb..39bd145ce55 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric.yml @@ -16,6 +16,7 @@ createSearchSecureBiometric: Partner_SearchSecureBiometric_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric outputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult @@ -32,11 +33,6 @@ createSearchSecureBiometric: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "providerId": "Tech-123" - } - ] }' Partner_SearchSecureBiometric_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/search @@ -75,6 +71,7 @@ createSearchSecureBiometric: Partner_SearchSecureBiometric_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/securebiometricinterface/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometric outputTemplate: partner/SearchAPIs/SearchSecureBiometric/createSearchSecureBiometricResult @@ -97,9 +94,4 @@ createSearchSecureBiometric: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "providerId": "Tech-123" - } - ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml index b1ed3f2c842..abeb2c92f11 100644 --- a/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml +++ b/automationtests/src/main/resources/partner/authPartner/RequestAPIKey/RequestAPIKey.yml @@ -41,7 +41,7 @@ RequestAPIKeyForAuthPartner: output: '{ "errors": [ { - "errorCode": "PMS_PRT_098", + "errorCode": "PMS_PRT_098" } ] }' diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml index d95c5c1c8cd..7669729d0a9 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/create/CreateDeviceDetail.yml @@ -2,6 +2,7 @@ createServiceToSaveDeviceDetail: Partner_ServiceToSaveDeviceDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/makeAndModel/create/createDeviceDetail outputTemplate: partner/device/makeAndModel/create/createDeviceDetailResult @@ -17,11 +18,12 @@ createServiceToSaveDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "device-id-123" + } }' Partner_ServiceToSaveDeviceDetail_sameMakeModelType_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/makeAndModel/create/createDeviceDetail outputTemplate: partner/device/makeAndModel/create/createDeviceDetailResult @@ -37,7 +39,6 @@ createServiceToSaveDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "device-id-124" }' Partner_ServiceToSaveDeviceDetail_sameMakeModel_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail @@ -148,8 +149,7 @@ createServiceToSaveDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.deviceProviderId" + "errorCode": "PMS_COR_001" } ] }' @@ -174,8 +174,7 @@ createServiceToSaveDeviceDetail: output: '{ "errors": [ { - "errorCode": "PMS_COR_001", - "message": "Invalid request parameter - value is empty or null :request.deviceSubTypeCode" + "errorCode": "PMS_COR_001" } ] }' diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs index 3d6bd8ac86b..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/create/createDeviceDetailResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "id": "{{id}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml index 6b5640bf2d2..a818d26522e 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml @@ -2,6 +2,7 @@ createServiceToUpdateDeviceDetail: Partner_ServiceToUpdateDeviceDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/device/makeAndModel/update/updateDeviceDetail outputTemplate: partner/device/makeAndModel/update/updateDeviceDetailResult @@ -18,7 +19,6 @@ createServiceToUpdateDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "device-id-123" }' Partner_ServiceToUpdateDeviceDetail_afterReject_InValid: @@ -40,7 +40,7 @@ createServiceToUpdateDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "device-id-124" + "id": "$IGNORE$" }' Partner_ServiceToUpdateDeviceDetail_Missing_InputParameter_DeviceId: diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index cbab1a3466e..2d1937c4b4b 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -419,8 +419,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-310", - "message": "Invalid column received : n@@@@@343e" + "errorCode": "PMS-MSD-310" } ] }' @@ -451,6 +450,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + + "errors": [ + { + "errorCode": "PMS_COR_003" + } + ] }' Partner_SearchPolicy_with_missing_type: endPoint: /v1/policymanager/policies/search @@ -481,8 +486,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-312", - "message": "Filter type is missing" + "errorCode": "PMS-MSD-312" } ] }' @@ -515,8 +519,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-358", - "message": "Sort type dc is not supported" + "errorCode": "PMS-MSD-358" } ] }' @@ -549,8 +552,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' @@ -583,8 +585,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-357", - "message": "Invalid sort field n@@@@3334$$$e" + "errorCode": "PMS-MSD-357" } ] }' @@ -617,8 +618,7 @@ createSearchPolicy: output: '{ "errors": [ { - "errorCode": "PMS-MSD-314", - "message": "Missing sort field or sort type values" + "errorCode": "PMS-MSD-314" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/Search/searchPolicyResult.hbs b/automationtests/src/main/resources/partner/policy/Search/searchPolicyResult.hbs index 10681fbf2fe..164c6468215 100644 --- a/automationtests/src/main/resources/partner/policy/Search/searchPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/Search/searchPolicyResult.hbs @@ -1,35 +1,13 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", "response": { - "fromRecord": "$IGNORE$", - "toRecord": "$IGNORE$", - "totalRecord": "$IGNORE$", "data": [ {{#each data}} { - "id": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "descr": "$IGNORE$", - "isActive": "$IGNORE$", - "isDeleted": "$IGNORE$", - "name": "$IGNORE$", - "policyFileId": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "validFromDate": "$IGNORE$", - "validToDate": "$IGNORE$", - "version": "{{version}}", "policyType": "{{policyType}}", - "schema": "{{schema}}", - "policyGroup": "$IGNORE$" + "schema": "{{schema}}" } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file From cf3b594bd47075e09c52b525cf3ece526644bcc5 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 29 Aug 2023 21:05:41 +0530 Subject: [PATCH 099/204] MOSIP-29086 --- .../partner/PartnerSearch/partnerSearch.yml | 20 +++++++++++++++++++ .../update/UpdateDeviceDetail.yml | 9 +++++++-- .../partner/policy/Search/SearchPolicy.yml | 2 +- 3 files changed, 28 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml index a3062a32cb5..f8058954030 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml +++ b/automationtests/src/main/resources/partner/PartnerSearch/partnerSearch.yml @@ -246,6 +246,11 @@ createSearchPartner: "version": "v1" }' output: '{ + "data": [ + { + "isActive": true + } + ] }' Partner_SearchPartner_columnname_id_asc_sid: @@ -276,6 +281,11 @@ createSearchPartner: "version": "v1" }' output: '{ + "data": [ + { + "isActive": true + } + ] }' Partner_SearchPartner_columnname_address_asc_sid: endPoint: /v1/partnermanager/partners/search @@ -305,6 +315,11 @@ createSearchPartner: "version": "v1" }' output: '{ + "data": [ + { + "isActive": true + } + ] }' Partner_SearchPartner_columnname_address_desc_sid: @@ -335,6 +350,11 @@ createSearchPartner: "version": "v1" }' output: '{ + "data": [ + { + "isActive": true + } + ] }' Partner_SearchPartner_with_invalid_value_containts: diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml index a818d26522e..a168615d584 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml @@ -19,6 +19,7 @@ createServiceToUpdateDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ + "id": "$IGNORE$" }' Partner_ServiceToUpdateDeviceDetail_afterReject_InValid: @@ -26,7 +27,7 @@ createServiceToUpdateDeviceDetail: role: partner restMethod: put inputTemplate: partner/device/makeAndModel/update/updateDeviceDetail - outputTemplate: partner/device/makeAndModel/update/updateDeviceDetailResult + outputTemplate: partner/error input: '{ "deviceProviderId": "Tech-123", "deviceSubTypeCode": "Single", @@ -40,7 +41,11 @@ createServiceToUpdateDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$" + "errors": [ + { + "errorCode": "PMS_COR_001" + } + ] }' Partner_ServiceToUpdateDeviceDetail_Missing_InputParameter_DeviceId: diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index 2d1937c4b4b..5048926559e 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -428,7 +428,7 @@ createSearchPolicy: role: partner restMethod: post inputTemplate: partner/policy/Search/searchPolicy - outputTemplate: partner/policy/Search/searchPolicyResult + outputTemplate: partner/error input: '{ "filters": [ { From c85164d1c69f9f1ecbecb8e007f6d89a059ed815 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 29 Aug 2023 21:12:53 +0530 Subject: [PATCH 100/204] MOSIP-29086 --- .../partner/device/makeAndModel/update/UpdateDeviceDetail.yml | 1 - .../device/makeAndModel/update/updateDeviceDetailResult.hbs | 3 --- 2 files changed, 4 deletions(-) diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml index a168615d584..e97a427e615 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml @@ -19,7 +19,6 @@ createServiceToUpdateDeviceDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$" }' Partner_ServiceToUpdateDeviceDetail_afterReject_InValid: diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs index 3d6bd8ac86b..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "id": "{{id}}" - } } \ No newline at end of file From 485656adde996a5681d9da26c30762867c9739ab Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 30 Aug 2023 10:38:19 +0530 Subject: [PATCH 101/204] MOSIP-29086 --- .../PartnerSearch/PartnerSearchResult.hbs | 9 +++-- .../SearchPartner/createSearchPartner.yml | 4 +-- .../createSearchPartnerResult.hbs | 5 +++ .../partner/policy/Search/SearchPolicy.yml | 33 +++++++++++++++---- 4 files changed, 40 insertions(+), 11 deletions(-) diff --git a/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs b/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs index 357b31a3ab1..5aa75187adf 100644 --- a/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs +++ b/automationtests/src/main/resources/partner/PartnerSearch/PartnerSearchResult.hbs @@ -1,13 +1,16 @@ { - + + "response": { + "data": [ {{#each data}} { - "isActive": "{{isActive}}" + + "isActive": {{isActive}} + } {{#unless @last}},{{/unless}} {{/each}} ] - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml index c1ec1b36229..bd652fc66b0 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml @@ -383,8 +383,8 @@ createSearchPartner: { "isActive": true } - ], - "errors": "[]" + ] + }' Partner_SearchPartner_with_invalid_columnName: endPoint: /v1/partnermanager/partners/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs index f5b21de0c2c..5aa75187adf 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartnerResult.hbs @@ -1,8 +1,13 @@ { + + "response": { + "data": [ {{#each data}} { + "isActive": {{isActive}} + } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index 5048926559e..46f462cd54d 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -14,6 +14,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + "data": [ + { + "policyType": "DataShare", + "schema": "https://schemas.mosip.io/v1/auth-policy" + } + ] }' Partner_SearchPolicy_Valid_Smoke: endPoint: /v1/policymanager/policies/search @@ -30,6 +36,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + "data": [ + { + "policyType": "DataShare", + "schema": "https://schemas.mosip.io/v1/auth-policy" + } + ] }' Partner_SearchPolicy_Only_FilterCriteria_Smoke: endPoint: /v1/policymanager/policies/search @@ -75,6 +87,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + "data": [ + { + "policyType": "DataShare", + "schema": "https://schemas.mosip.io/v1/auth-policy" + } + ] }' Partner_SearchPolicy_Only_PaginationCriteria_Smoke: endPoint: /v1/policymanager/policies/search @@ -91,6 +109,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + "data": [ + { + "policyType": "DataShare", + "schema": "https://schemas.mosip.io/v1/auth-policy" + } + ] }' Partner_SearchPolicy_type_contains_Smoke_asc: endPoint: /v1/policymanager/policies/search @@ -191,9 +215,8 @@ createSearchPolicy: output: '{ "data": [ { - "version": "1.0", "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' @@ -226,9 +249,8 @@ createSearchPolicy: output: '{ "data": [ { - "version": "1.0", "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' @@ -261,9 +283,8 @@ createSearchPolicy: output: '{ "data": [ { - "version": "1.0", "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' From 96a8038ddb96cc744729718e0cf532cd4df6afa5 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 30 Aug 2023 11:08:56 +0530 Subject: [PATCH 102/204] MOSIP-29086 --- .../SearchAPIs/SearchPolicy/createSearchPolicy.yml | 14 +++++++++++++- .../partner/policy/Search/SearchPolicy.yml | 8 ++++---- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml index f92c3582045..5133baeb4bd 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicy/createSearchPolicy.yml @@ -66,6 +66,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + "data": [ + { + "policyType": "DataShare", + "schema": "$IGNORE$" + } + ] }' Partner_SearchPolicy_Only_PaginationCriteria_Smoke: endPoint: /partnermanagement/v1/policies/policy/search @@ -82,6 +88,12 @@ createSearchPolicy: "version": "v1" }' output: '{ + "data": [ + { + "policyType": "DataShare", + "schema": "$IGNORE$" + } + ] }' Partner_SearchPolicy_type_contains_Smoke_asc_sid: endPoint: /partnermanagement/v1/policies/policy/search @@ -149,7 +161,7 @@ createSearchPolicy: { "version": "1.0", "policyType": "Auth", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index 46f462cd54d..d92711efe07 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -17,7 +17,7 @@ createSearchPolicy: "data": [ { "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' @@ -39,7 +39,7 @@ createSearchPolicy: "data": [ { "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' @@ -90,7 +90,7 @@ createSearchPolicy: "data": [ { "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' @@ -112,7 +112,7 @@ createSearchPolicy: "data": [ { "policyType": "DataShare", - "schema": "https://schemas.mosip.io/v1/auth-policy" + "schema": "$IGNORE$" } ] }' From 251fb31689d4bf8872ea0c3b30e67a7a50af5248 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 30 Aug 2023 11:40:48 +0530 Subject: [PATCH 103/204] MOSIP-29086 --- .../src/main/resources/idRepository/CreateDraft/CreateDraft.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml b/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml index 2ce612c6d0e..26051d68ad2 100644 --- a/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml +++ b/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml @@ -32,13 +32,13 @@ CreateDraft: endPoint: /idrepository/v1/identity/draft/create/{registrationId} role: idrepo restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: idRepository/CreateDraft/createDraft outputTemplate: idRepository/CreateDraft/createDraftResult input: '{ "registrationId":"$RIDDEL$" }' output: '{ - "status": "DRAFTED" }' IdRepository_CreateDraft_invalid_rid: endPoint: /idrepository/v1/identity/draft/create/{registrationId} From 8b21b20ef13cd32b2405653b966df0c89de4be4d Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 30 Aug 2023 11:59:12 +0530 Subject: [PATCH 104/204] MOSIP-29086 --- .../partner/GetPartnersPolicy/getPartnersPolicyResult.hbs | 4 ++-- .../src/main/resources/partner/policy/Search/SearchPolicy.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs b/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs index 08a89e13d3c..d6a55db744a 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs @@ -2,8 +2,8 @@ "response": { "policyGroupId": "{{policyGroupId}}", "policyGroupName": "{{policyGroupName}}", - "policyId": "policyId", - "policyName": "policyName", + "policyId": "{{policyId}}", + "policyName": "{{policyName}}", "status": "{{status}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index d92711efe07..67ef3fedb43 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -89,7 +89,7 @@ createSearchPolicy: output: '{ "data": [ { - "policyType": "DataShare", + "policyType": "Datashare", "schema": "$IGNORE$" } ] From 3911454ae10b45c3da74657b297f7bee66dbab6e Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 30 Aug 2023 17:41:38 +0530 Subject: [PATCH 105/204] MOSIP-29147 --- .../resources/resident/GenerateVID/createGenerateVIDNew.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml index df29823f767..43a499438bc 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml @@ -74,6 +74,7 @@ GenerateVIDNew: Resident_Generate_Perpetual_VID_uin_Email_Valid_Smoke_sid: endPoint: /resident/v1/generate-vid role: residentNew + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GenerateVID/createGenerateVIDNewAsEmail outputTemplate: resident/GenerateVID/createGenerateVIDNewResult @@ -85,8 +86,7 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - "maskedPhone": "$IGNORE$", - "maskedEmail": "res***************@gmail.com" + "maskedPhone": "$IGNORE$" }' Resident_Generate_Perpetual_VID_BothChannel_uin_Valid_Smoke_sid: From 8fcdd9ae28ba24f02e929e6c2a0f9fc9a68b9a2e Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Wed, 30 Aug 2023 18:01:31 +0530 Subject: [PATCH 106/204] MOSIP-29127 --- .../mosip/testrig/apirig/global/utils/GlobalMethods.java | 7 +++++++ .../main/java/io/mosip/testrig/apirig/report/Reporter.java | 3 +++ 2 files changed, 10 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java index 422b79f0fac..b722f4c2e89 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java @@ -7,6 +7,13 @@ public class GlobalMethods { + + public static void ReportRequestAndResponse(String reqHeader,String resHeader,String url, String requestBody, String response) { + reportRequest(reqHeader,requestBody); + reportResponse(resHeader,url, response); + } + + public static void reportRequest(String requestHeader, String request) { String formattedHeader = ReportUtil.getTextAreaForHeaders(requestHeader); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/report/Reporter.java b/automationtests/src/main/java/io/mosip/testrig/apirig/report/Reporter.java index 9c2b42b2793..6d4c78a508c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/report/Reporter.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/report/Reporter.java @@ -19,6 +19,9 @@ public class Reporter { private static final Logger REPORTLOG = Logger.getLogger(Reporter.class); + + + public static String getAppDepolymentVersion() { MavenXpp3Reader reader = new MavenXpp3Reader(); Model model = null; From c55f22db18fb358e23d541a1b81be6b5a136f6df Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 30 Aug 2023 18:55:23 +0530 Subject: [PATCH 107/204] MOSIP-28845 --- .../apirig/admin/fw/util/AdminTestUtil.java | 12 ++++----- .../testrig/apirig/service/BaseTestCase.java | 1 + .../apirig/testrunner/MosipTestRunner.java | 2 ++ .../masterdata/Device/CreateDevice.yml | 26 +++++++++---------- .../masterdata/Device/UpdateDevice.yml | 26 +++++++++---------- .../masterdata/Machine/CreateMachine.yml | 22 ++++++++-------- .../masterdata/Machine/UpdateMachine.yml | 20 +++++++------- .../masterdata/ZoneUser/CreateZoneUser.yml | 6 ++--- .../masterdata/ZoneUser/UpdateZoneUser.yml | 4 +-- 9 files changed, 61 insertions(+), 58 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 9b014e3fb86..2f7d0ef4f46 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -2777,7 +2777,8 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$MISPPARTNEREMAIL$", genMispPartnerEmail); - + if (jsonString.contains("$ZONE_CODE$")) + jsonString = replaceKeywordWithValue(jsonString, "$ZONE_CODE$", ZonelocationCode); if (jsonString.contains("$LOCATIONCODE$")) jsonString = replaceKeywordWithValue(jsonString, "$LOCATIONCODE$", locationCode); @@ -5108,9 +5109,10 @@ public static void getZoneName() { String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); - HashMap map = new HashMap<>(); - map.put("userID", ConfigManager.getUserAdminName()); + Map map = new HashMap<>(); + map.put("langCode", BaseTestCase.getLanguageList().get(0)); + map.put("userID", "masterdata-"+ConfigManager.getUserAdminName()); try { @@ -5122,10 +5124,8 @@ public static void getZoneName() { try { JSONObject responseObject = responseJson.getJSONObject("response"); - JSONArray data = responseObject.getJSONArray("locations"); - JSONObject entry = data.getJSONObject(0); - locationCode = entry.getString("code"); + ZonelocationCode = responseObject.getString("zoneCode"); } catch (Exception e) { logger.error(e.getMessage()); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index b7bf3fade0d..be5e6c16379 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -131,6 +131,7 @@ public class BaseTestCase { public static String parentLocCode = ""; public static String locationCode = ""; + public static String ZonelocationCode = ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 48a6df0ba18..9d62b4402c5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -105,6 +105,8 @@ public static void main(String[] arg) { AdminTestUtil.getLocationData(); BaseTestCase.mapUserToZone(); BaseTestCase.mapZone(); + AdminTestUtil.getZoneName(); + for (int i = 0; i < localLanguageList.size(); i++) { BaseTestCase.languageList.clear(); diff --git a/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml b/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml index 8e236f24844..9f0bcd81d62 100644 --- a/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml +++ b/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml @@ -14,7 +14,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -26,7 +26,7 @@ CreateDevice: "isActive": false, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -46,7 +46,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -58,7 +58,7 @@ CreateDevice: "isActive": false, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -78,7 +78,7 @@ CreateDevice: "isActive": true, "langCode": "ara", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "2018-12-24T05", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -134,7 +134,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -162,7 +162,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -218,7 +218,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -246,7 +246,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -274,7 +274,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "", "requesttime": "$TIMESTAMP$" @@ -302,7 +302,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", "requesttime": "$TIMESTAMP$" @@ -330,7 +330,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -358,7 +358,7 @@ CreateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" diff --git a/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml b/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml index b454a3760f1..a6ff614dba0 100644 --- a/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml +++ b/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml @@ -14,7 +14,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -26,7 +26,7 @@ UpdateDevice: "isActive": "$IGNORE$", "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -46,7 +46,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -58,7 +58,7 @@ UpdateDevice: "isActive": "$IGNORE$", "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -78,7 +78,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "2018-12-24T05", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -133,7 +133,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -161,7 +161,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -217,7 +217,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -245,7 +245,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -273,7 +273,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "", "requesttime": "$TIMESTAMP$" @@ -301,7 +301,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", "requesttime": "$TIMESTAMP$" @@ -329,7 +329,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -357,7 +357,7 @@ UpdateDevice: "isActive": true, "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" diff --git a/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml b/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml index 6c7dd4caa12..0e15a053988 100644 --- a/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml +++ b/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml @@ -18,7 +18,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"$PUBLICKEY$", "signPublicKey":"$PUBLICKEY$", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -30,7 +30,7 @@ CreateMachine: "isActive": "$IGNORE$", "langCode": "eng", "macAddress": "61-D3-FD-12-C9-ED", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$IGNORE$" }' Masterdata_CreateMachine_Invalid_publicKey: @@ -52,7 +52,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"anyRandomString", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -82,7 +82,7 @@ CreateMachine: "validityDateTime":"2018-12-24T05", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -142,7 +142,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -232,7 +232,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -262,7 +262,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -292,7 +292,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -322,7 +322,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -352,7 +352,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -382,7 +382,7 @@ CreateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ diff --git a/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml b/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml index 8297965b4d2..66901fbb7ff 100644 --- a/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml +++ b/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml @@ -18,7 +18,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"$PUBLICKEY$", "signPublicKey":"$PUBLICKEY$", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -30,7 +30,7 @@ UpdateMachine: "isActive": "$IGNORE$", "langCode": "$IGNORE$", "macAddress": "61-D3-FD-12-C9-ED", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "validityDateTime": "$IGNORE$" }' Masterdata_UpdateMachine_Invalid_validitydate_Format: @@ -52,7 +52,7 @@ UpdateMachine: "validityDateTime":"2018-12-24T05", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -112,7 +112,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -202,7 +202,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -232,7 +232,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -262,7 +262,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -292,7 +292,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -322,7 +322,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -352,7 +352,7 @@ UpdateMachine: "validityDateTime":"2021-12-24T05:52:46.758Z", "publicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", "signPublicKey":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCPeK0rYSEqIhX1m4X8fk78zEhO7GTdzKE3spKlRqMc2l3fCDu0QjvC55F9saq+7fM8+oz/RDcLWOvsRl+4tLST5s86mKfsTjqmjnmUZTezSz8lb3/8YDl/K9TxOhpxXbYh9hvQ3J9Is7KECTzj1VAmmqc3HCrw/F8wC2T9wsLaIwIDAQAB", - "zoneCode":"CST", + "zoneCode":"$ZONE_CODE$", "requesttime": "$TIMESTAMP$" }' output: '{ diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml b/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml index 508867b76b8..defdbc91deb 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml @@ -6,14 +6,14 @@ CreateZoneUser: inputTemplate: masterdata/ZoneUser/zoneUser outputTemplate: masterdata/ZoneUser/zoneUserResult input: '{ - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "userId": "func_auto_test_user", "isActive": true, "langCode": "eng", "requesttime": "$TIMESTAMP$" }' output: '{ - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "userId": "func_auto_test_user" }' @@ -24,7 +24,7 @@ CreateZoneUser: inputTemplate: masterdata/ZoneUser/zoneUser outputTemplate: masterdata/error input: '{ - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "userId": "", "isActive": true, "langCode": "eng", diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml b/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml index 536ab79e410..ef19caea8fa 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml @@ -6,11 +6,11 @@ UpdateZoneUser: inputTemplate: masterdata/ZoneUser/updateZoneUser outputTemplate: masterdata/ZoneUser/zoneUserResult input: '{ - "zoneCode": "BSN", + "zoneCode": "$ZONE_CODE$", "userId": "func_auto_test_user", "requesttime": "$TIMESTAMP$" }' output: '{ - "zoneCode": "BSN", + "zoneCode": "$ZONE_CODE$", "userId": "func_auto_test_user" }' \ No newline at end of file From fe3b1014c25728709c059f6c1f8810ad9f6e5eb5 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 30 Aug 2023 19:04:13 +0530 Subject: [PATCH 108/204] MOSIP-29140 --- .../src/main/resources/resident/AuthHistory/AuthHistory.yml | 2 +- .../CredentialIssuance/RequestCredentials/ReqCredential.yml | 4 ++-- .../resident/GetIdentityMapping/GetIdentityMapping.yml | 2 +- .../GetRemainingupdatecountbyIndividualIdRequest.yml | 2 +- .../resident/GetRequestCardVid/GetRequestCardVid.yml | 4 ++-- .../resident/GetServiceHistory/GetServiceHistory.yml | 4 ++-- .../resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml | 4 ++-- 7 files changed, 11 insertions(+), 11 deletions(-) diff --git a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml index c765c0eb055..2509a77a4c2 100644 --- a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml +++ b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml @@ -88,7 +88,7 @@ AuthHistory: output: '{ "errors": [ { - "errorCode": "RES-SER-417", + "errorCode": "RES-SER-410", "message": "$IGNORE$" } ], diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml index a82d271fe5b..89cea0587ea 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -426,7 +426,7 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-412", + "errorCode": "RES-SER-410", "message": "$IGNORE$" } ], @@ -463,7 +463,7 @@ RequestCredentials: output: '{ "errors": [ { - "errorCode": "RES-SER-412" + "errorCode": "RES-SER-410" } ], "sendOtpResp":{ diff --git a/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml b/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml index f6ae77decff..8e3a0d0a4d1 100644 --- a/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml +++ b/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml @@ -1,6 +1,6 @@ GetIdentityMapping: Resident_GetIdentityMapping_all_Valid_Smoke: - endPoint: /resident/v1/proxy/config/identity-mapping + endPoint: /resident/v1/auth-proxy/config/identity-mapping role: resident checkErrorsOnlyInResponse: true restMethod: get diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml index 1a6750d77c8..cff766f9072 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml @@ -52,7 +52,7 @@ GetRemainingupdatecountbyIndividualIdRequest: Resident_GetRemainingupdatecountbyIndividualIdRequest_Invalid_Token: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} - role: invalid + role: partner checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest diff --git a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml index 7f0c19b29ad..e8503d466d2 100644 --- a/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml +++ b/automationtests/src/main/resources/resident/GetRequestCardVid/GetRequestCardVid.yml @@ -62,7 +62,7 @@ GetRequestCardVid: output: '{ "errors": [ { - "errorCode": "RES-SER-454" + "errorCode": "RES-SER-406" } ] }' @@ -110,7 +110,7 @@ GetRequestCardVid: output: '{ "errors": [ { - "errorCode": "RES-SER-454", + "errorCode": "RES-SER-406", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml index 3eac5ec983e..588d597cb91 100644 --- a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml +++ b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml @@ -650,7 +650,7 @@ GetServiceHistory: "toDate": "$REMOVE$", "sortType": "$REMOVE$", "serviceType": "$REMOVE$", - "statusFilter": "In progress, Success, Failed", + "statusFilter": "SUCCESS,IN_PROGRESS,FAILED", "searchText": "$REMOVE$" }' output: '{ @@ -2024,7 +2024,7 @@ GetServiceHistory: "toDate": "$REMOVE$", "sortType": "$REMOVE$", "serviceType": "$REMOVE$", - "statusFilter": "In progress, Success, Failed", + "statusFilter": "SUCCESS,IN_PROGRESS,FAILED", "searchText": "$REMOVE$" }' output: '{ diff --git a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml index 2df946a782f..aa0bd23e8de 100644 --- a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml +++ b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml @@ -89,7 +89,7 @@ RevokeVIDNew: ] }' Resident_RevokeVIDNew_Using_Vid_Valid_Smoke: - endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_1_Esignet_Integ_Valid_Smoke_sid_vid$ + endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Onetimeuse_Using_VID_Valid_Smoke_sid_vid$ role: residentNewVid checkErrorsOnlyInResponse: true restMethod: patch @@ -106,7 +106,7 @@ RevokeVIDNew: }' Resident_RevokeVIDNew_uin_Using_Vid_Invalid_User_Neg: - endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_Temporary_2_Esignet_Integ_Valid_Smoke_sid_vid$ + endPoint: /resident/v1/revoke-vid/$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$ role: residentNew checkErrorsOnlyInResponse: true restMethod: patch From bf24048110e0fe9f901c38075e61f48a95e22281 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 31 Aug 2023 11:43:59 +0530 Subject: [PATCH 109/204] MOSIP-29140 --- .../GetRemainingupdatecountbyIndividualIdRequest.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml index cff766f9072..85f58dee9c9 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml @@ -63,5 +63,9 @@ GetRemainingupdatecountbyIndividualIdRequest: "attribute_list": "fullName" }' output: '{ - + "errors": [ + { + "errorCode": "KER-ATH-403" + } + ] }' \ No newline at end of file From 3d3f460889fad2c9aa56bfa146d356213dc23239 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 31 Aug 2023 11:45:26 +0530 Subject: [PATCH 110/204] MOSIP-29140 --- .../resources/resident/GetServiceHistory/GetServiceHistory.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml index 588d597cb91..0a1f20838c8 100644 --- a/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml +++ b/automationtests/src/main/resources/resident/GetServiceHistory/GetServiceHistory.yml @@ -1361,7 +1361,7 @@ GetServiceHistory: "toDate": "$REMOVE$", "sortType": "$REMOVE$", "serviceType": "$REMOVE$", - "statusFilter": "In progress, Success, Failed", + "statusFilter": "SUCCESS,IN_PROGRESS,FAILED", "searchText": "$REMOVE$" }' output: '{ From e1cdc9790b0dfd40b5544c6cad37ccb03e2400e2 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 31 Aug 2023 11:48:51 +0530 Subject: [PATCH 111/204] MOSIP-29140 --- .../GetIdentityMapping/GetIdentityMapping.yml | 2 +- automationtests/testNgXmlFiles/residentApi.xml | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml b/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml index 8e3a0d0a4d1..a5aa8140ba1 100644 --- a/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml +++ b/automationtests/src/main/resources/resident/GetIdentityMapping/GetIdentityMapping.yml @@ -1,7 +1,7 @@ GetIdentityMapping: Resident_GetIdentityMapping_all_Valid_Smoke: endPoint: /resident/v1/auth-proxy/config/identity-mapping - role: resident + role: residentNew checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetIdentityMapping/getIdentityMapping diff --git a/automationtests/testNgXmlFiles/residentApi.xml b/automationtests/testNgXmlFiles/residentApi.xml index 239d40a35c2..188a372aa94 100644 --- a/automationtests/testNgXmlFiles/residentApi.xml +++ b/automationtests/testNgXmlFiles/residentApi.xml @@ -270,13 +270,6 @@ - - - - - - @@ -341,6 +334,13 @@ + + + + + + From 3236f9fad92ff936f0ea60a3f6e45475f9eab1f0 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 31 Aug 2023 17:36:23 +0530 Subject: [PATCH 112/204] MOSIP-29156 MOSIP-29157 --- .../esignet/AddIdentity/AddIdentity.yml | 27 +++++++++++++++ .../AuthenticateUserVCI.hbs | 15 +++++++++ .../AuthenticateUserVCI.yml | 33 +++++++++++++++++++ .../AuthenticateUserVCIResult.hbs | 1 + .../OAuthDetailsRequestVCI.hbs | 17 ++++++++++ .../OAuthDetailsRequestVCI.yml | 26 +++++++++++++++ .../OAuthDetailsRequestVCIResult.hbs | 1 + 7 files changed, 120 insertions(+) create mode 100644 automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs diff --git a/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml index 51323060568..ab4285eb9e3 100644 --- a/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml @@ -402,4 +402,31 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + + ESignet_AddIdentity_Valid_Params_VCI_uin_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: esignet/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: esignet/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "ESignet_AddIdentity_Valid_Params_VCI_uin_smoke_Pos@mosip.net", + "phone": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.hbs b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.hbs new file mode 100644 index 00000000000..887633e1120 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.hbs @@ -0,0 +1,15 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "individualId": "{{individualId}}", + "challengeList" : [ + { + "authFactorType" : "{{authFactorType}}", + "challenge" : "{{challenge}}", + "format": "alpha-numeric" + } + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml new file mode 100644 index 00000000000..48cdf9d92d3 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -0,0 +1,33 @@ +AuthenticateUserVCI: + ESignet_AuthenticateUserVCI_uin_Otp_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs new file mode 100644 index 00000000000..6dec068b531 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs @@ -0,0 +1,17 @@ +{ + "requestTime": "{{requestTime}}", + "request": { + "clientId": "{{clientId}}", + "scope": "{{scope}}", + "responseType": "{{responseType}}", + "redirectUri": "{{redirectUri}}", + "display": "{{display}}", + "prompt": "{{prompt}}", + "acrValues": "{{acrValues}}", + "nonce" : "{{nonce}}", + "state" : "{{state}}", + "claimsLocales" : "{{claimsLocales}}", + "codeChallenge" : "{{codeChallenge}}", + "codeChallengeMethod" : "{{codeChallengeMethod}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml new file mode 100644 index 00000000000..3f2451c9139 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -0,0 +1,26 @@ +OAuthDetailsRequestVCI: + ESignet_OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "sample_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file From 63e16765ea187bf14d086b3269b099a6916f7079 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Fri, 1 Sep 2023 15:39:55 +0530 Subject: [PATCH 113/204] reporter --- .../mosip/testrig/apirig/authentication/fw/util/ReportUtil.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java index b44be38b991..66fe613968b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java @@ -25,7 +25,7 @@ public class ReportUtil { */ public static String getTextAreaForHeaders(String headers) { String formattedHeader = "No headers"; - if (headers != null) + if (headers != null && !headers.isEmpty()) formattedHeader = headers; StringBuilder sb = new StringBuilder(); sb.append("
"); return sb.toString(); } From d47f78f7a048e777c32893f8345138f344597c5a Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 11 Sep 2023 18:45:18 +0530 Subject: [PATCH 133/204] MOSIP-29378 MOSIP-29379 --- .../fw/util/OutputValidationUtil.java | 7 +- .../AuthenticateUserVCI.yml | 231 ++++++++++++++++++ .../AuthorizationCodeVCI.yml | 137 ++++++++++- .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 80 ++++++ .../OAuthDetailsRequestVCI.yml | 158 +++++++++++- .../src/main/resources/esignet/error2.hbs | 3 +- 6 files changed, 611 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index ef9294cb781..284a372934a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -494,12 +494,17 @@ public static boolean doesResponseHasErrors(String responseString) { JSONObject responseJson = new JSONObject(responseString); boolean breturn = false; JSONArray errors = null; + String error = null; if (responseJson.has("errors")) { errors = responseJson.optJSONArray("errors"); } - + else if (responseJson.has("error")) { + error = responseJson.getString("error"); + } if (errors != null) breturn = (errors.length() > 0); + else if (error != null) + breturn = true; return breturn; } diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index 46bd2c90915..b336e306111 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -63,4 +63,235 @@ AuthenticateUserVCI: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_Diff_Scope_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen1_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_Hash_CodeChallenge_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 854a7df51bf..e327fad317a 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -22,12 +22,147 @@ AuthorizationCodeVCI: checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + outputTemplate: esignet/error input: '{ "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", "requestTime": "$TIMESTAMP$", "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", "permittedAuthorizeScopes": [{scope: "sdfsfd"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Empty_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: ""}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Invalid_Comma_Separated_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "sdfaf, asdf"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Invalid_Diff_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "mosip_identity_vc_ldp"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegTokenScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegTokenScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$" }' output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index 474bd7d88ee..295ef1fbc14 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -17,4 +17,84 @@ GenerateTokenVCI: }' output: '{ "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegTokenScen1_Invalid_code_verifier: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "sdgfhss" +}' + output: '{ + "error": "pkce_failed" +}' + + ESignet_GenerateTokenVCI_uin_NegTokenScen2_Empty_code_verifier: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen2_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "" +}' + output: '{ + "error": "invalid_pkce_code_verifier" +}' + + ESignet_GenerateTokenVCI_uin_NegTokenScen3_NoHash_code_verifier: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen3_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" +}' + output: '{ + "error": "pkce_failed" +}' + + ESignet_GenerateTokenVCI_uin_Invalid_Hash_CodeChallenge: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" +}' + output: '{ + "error": "pkce_failed" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index a457547e196..63393b046a1 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -55,7 +55,7 @@ OAuthDetailsRequestVCI: ] }' - ESignet_OAuthDetailsRequest_VCI_uin_Diff_Scope: + ESignet_OAuthDetailsRequest_VCI_uin_Diff_Scope_sid: endPoint: /v1/esignet/authorization/v2/oauth-details role: resident restMethod: post @@ -329,4 +329,160 @@ OAuthDetailsRequestVCI: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk", + "codeChallengeMethod": "S256" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/error2.hbs b/automationtests/src/main/resources/esignet/error2.hbs index 9b0452d7d5e..76b865e9d93 100644 --- a/automationtests/src/main/resources/esignet/error2.hbs +++ b/automationtests/src/main/resources/esignet/error2.hbs @@ -1,4 +1,3 @@ { - "error": "{{error}}", - "error_description": "$IGNORE$" + "error": "{{error}}" } \ No newline at end of file From c999a1d1dacae9abdc06ba06bab0bb845280c450 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Mon, 11 Sep 2023 19:16:58 +0530 Subject: [PATCH 134/204] MOSIP-29383 --- .../ActivateDeactivatePartnerApiKey.yml | 42 +++++++++++++++++++ .../DeviceDetailsFilter.yml | 19 +++++++++ .../MapPartnerAndPolicytoCredentialType.yml | 38 +++++++++++++++++ .../MapDeviceWithSBI/MapDeviceWithSBI.yml | 13 ++++++ .../create/CreateSecureBiometricInterface.yml | 18 ++++++++ .../reject/RejectSecureBiometricInterface.yml | 41 ++++++++++++++++++ 6 files changed, 171 insertions(+) diff --git a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml index 7f13b239361..3c76df7eb38 100644 --- a/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml +++ b/automationtests/src/main/resources/partner/ActivateDeactivatePartnerApiKey/ActivateDeactivatePartnerApiKey.yml @@ -91,4 +91,46 @@ ActivateDeactivatePartnerApiKey: "errorCode": "PMS_PRT_111" } ] +}' + + Partner_ActivateDeactivatePartnerApiKey_activate_Dublicate_Lable_Neg: + endPoint: /v1/partnermanager/partners/{partnerId}/policy/{policyId}/apiKey/status + role: partner + restMethod: patch + inputTemplate: partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKey + outputTemplate: partner/error + input: '{ + "partnerId": "partner-111997", + "policyId": "MDSPK", + "label": "string", + "requesttime": "$TIMESTAMP$", + "status": "Active" +}' + output: '{ + "errors": [ + { + "errorCode": "PMS_PRT_111" + } + ] +}' + + Partner_ActivateDeactivatePartnerApiKey_Lable_Removed_Neg: + endPoint: /v1/partnermanager/partners/{partnerId}/policy/{policyId}/apiKey/status + role: partner + restMethod: patch + inputTemplate: partner/ActivateDeactivatePartnerApiKey/activateDeactivatePartnerApiKey + outputTemplate: partner/error + input: '{ + "partnerId": "partner-111997", + "policyId": "MDSP", + "label": "$REMOVE$", + "requesttime": "$TIMESTAMP$", + "status": "Active" +}' + output: '{ + "errors": [ + { + "errorCode": "PMS_COR_001" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml index d6dfe5304c5..8cc2fe86997 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml @@ -17,6 +17,25 @@ DeviceDetailsFilter: }' output: '{ }' + + partner_DeviceDetailsFilter_To_MapSBI: + endPoint: /v1/partnermanager/devicedetail/filtervalues + role: partner + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilter + outputTemplate: partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult + input: '{ + "filters": [{ + "columnName": "id", + "type": "unique", + "text": "device-id-321" + }], + "purpose": "REGISTRATION", + "requesttime": "$TIMESTAMP$" +}' + output: '{ +}' partner_DeviceDetailsFilter_all_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/filtervalues role: partner diff --git a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml index 0277e5289a6..30901a9465e 100644 --- a/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml +++ b/automationtests/src/main/resources/partner/MapPartnerAndPolicytoCredentialType/MapPartnerAndPolicytoCredentialType.yml @@ -66,4 +66,42 @@ MapPartnerAndPolicytoCredentialType: "errorCode": "PMS_PRT_072" } ] +}' + + Partner_MapPartnerAndPolicytoCredentialType_MapTo_Inactive_Policy_Neg: + endPoint: /v1/partnermanager/partners/{partnerId}/credentialtype/{credentialType}/policies/{policyId} + role: partner + restMethod: post + inputTemplate: partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialType + outputTemplate: partner/error + input: '{ + "partnerId": "MISP3", + "credentialType": "auth", + "policyId": "mosip policy" +}' + output: '{ + "errors": [ + { + "errorCode": "PMS_PMP_016" + } + ] +}' + + Partner_MapPartnerAndPolicytoCredentialType_Map_Again_Dublicate_Neg: + endPoint: /v1/partnermanager/partners/{partnerId}/credentialtype/{credentialType}/policies/{policyId} + role: partner + restMethod: post + inputTemplate: partner/MapPartnerAndPolicytoCredentialType/mapPartnerAndPolicytoCredentialType + outputTemplate: partner/error + input: '{ + "partnerId": "MOVP", + "credentialType": "auth", + "policyId": "mosip policy" +}' + output: '{ + "errors": [ + { + "errorCode": "PMS_PRT_072" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml index 6a55155ba77..b2139eb71bf 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/MapDeviceWithSBI/MapDeviceWithSBI.yml @@ -26,6 +26,19 @@ MapDeviceWithSBI: output: '{ }' + Partner_MapDeviceWithSBI_Multiple_map_smoke: + endPoint: /v1/partnermanager/securebiometricinterface/devicedetails/map + role: partner + restMethod: put + inputTemplate: partner/device/SecureBiometricInterface/MapDeviceWithSBI/mapDeviceWithSBI + outputTemplate: partner/error + input: '{ + "deviceDetailId": "device-id-123", + "sbiId": "$ID:SaveSecureBiometricInterface_TO_Map_sid_id$" + }' + output: '{ + }' + Partner_MapDeviceWithSBI_Multiple_MapDeviceWith_Diff_Provider: endPoint: /v1/partnermanager/securebiometricinterface/devicedetails/map role: partner diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml index 2c88d0b2507..3a0ec3be2da 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/create/CreateSecureBiometricInterface.yml @@ -34,6 +34,24 @@ createSaveSecureBiometricInterface: output: '{ }' + Partner_SaveSecureBiometricInterface_TO_Map_sid: + endPoint: /v1/partnermanager/securebiometricinterface + role: partner + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: partner/device/SecureBiometricInterface/create/createSecureBiometricInterface + outputTemplate: partner/device/SecureBiometricInterface/create/createSecureBiometricInterfaceResult + input: '{ + "swBinaryHash": "0", + "swCreateDateTime": "$TIMESTAMP$", + "swExpiryDateTime": "2222-12-30T08:23:57.986Z", + "swVersion": "MO.TD.04", + "requesttime": "$TIMESTAMP$", + "providerId": "Tech-123" + }' + output: '{ + }' + Partner_SaveSecureBiometricInterface_dublicate_swVersion_Neg: endPoint: /v1/partnermanager/securebiometricinterface role: partner diff --git a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml index 39636c2c2f5..8844811c67b 100644 --- a/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml +++ b/automationtests/src/main/resources/partner/device/SecureBiometricInterface/reject/RejectSecureBiometricInterface.yml @@ -29,6 +29,47 @@ RejectSecureBiometricInterface: }' output: '{ }' + + Partner_RejectSecureBiometricInterface_DEActive_TO_Map: + endPoint: /v1/partnermanager/securebiometricinterface + role: partner + restMethod: patch + inputTemplate: partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterface + outputTemplate: partner/error + input: '{ + "approvalStatus": "De-activate", + "id": "$ID:SaveSecureBiometricInterface_TO_Map_sid_id$", + "isItForRegistrationDevice": true, + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "PMS_COR_001" + } + ] + }' + + Partner_RejectSecureBiometricInterface_SpaVal_neg: + endPoint: /v1/partnermanager/securebiometricinterface + role: partner + restMethod: patch + inputTemplate: partner/device/SecureBiometricInterface/reject/rejectSecureBiometricInterface + outputTemplate: partner/error + input: '{ + "approvalStatus": "De-activate", + "id": "$ID:SaveSecure BiometricInterface_TO_Map_sid_id$", + "isItForRegistrationDevice": true, + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "PMS_COR_001" + } + ] + }' + Partner_RejectSecureBiometricInterface_Missing_InputParameter_approvalStatus: endPoint: /v1/partnermanager/securebiometricinterface role: partner From 65585585aee50a671baf99e79b8592136361303f Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 11 Sep 2023 23:07:16 +0530 Subject: [PATCH 135/204] MOSIP-29286 --- .../ida/AuthTransaction/AuthTransaction.yml | 78 ++++++++ .../main/resources/ida/DemoAuth/DemoAuth.hbs | 27 +++ .../main/resources/ida/DemoAuth/DemoAuth.yml | 186 ++++++++++++++++++ 3 files changed, 291 insertions(+) diff --git a/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml b/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml index 481273a2939..f6d1fed8eea 100644 --- a/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml +++ b/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml @@ -50,4 +50,82 @@ AuthTransaction: }' output: '{ "referenceIdType": "VID" +}' + auth_AuthTransaction_allValid_smoke_VID2: + endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} + role: resident + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: ida/AuthTransaction/authTransaction + outputTemplate: ida/AuthTransaction/authTransactionResult + input: '{ + "individualId":"$ID:GenerateVID_All_Valid_Smoke_deactivate_Perpetual_sid_vid$" +}' + output: '{ + "referenceIdType": "VID" +}' + auth_AuthTransaction_allValid_smoke_VID3: + endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} + role: resident + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: ida/AuthTransaction/authTransaction + outputTemplate: ida/AuthTransaction/authTransactionResult + input: '{ + "individualId":"$ID:GenerateVID_All_Valid_Smoke_Temp_VID_sid_vid$" +}' + output: '{ + "referenceIdType": "VID" +}' + auth_AuthTransaction_allValid_smoke_UIN2: + endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} + role: resident + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: ida/AuthTransaction/authTransaction + outputTemplate: ida/AuthTransaction/authTransactionResult + input: '{ + "individualId":"$ID:AddIdentity_withValidParameters_Infant_smoke_Pos_UIN$" +}' + output: '{ + "referenceIdType": "UIN" +}' + auth_AuthTransaction_allValid_smoke_UIN3: + endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} + role: resident + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: ida/AuthTransaction/authTransaction + outputTemplate: ida/AuthTransaction/authTransactionResult + input: '{ + "individualId":"$ID:AddIdentity_ValidParam_smoke_Pos_UIN$" +}' + output: '{ + "referenceIdType": "UIN" +}' + auth_AuthTransaction_allValid_smoke_UIN4: + endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} + role: resident + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: ida/AuthTransaction/authTransaction + outputTemplate: ida/AuthTransaction/authTransactionResult + input: '{ + "individualId":"$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$" +}' + output: '{ + "referenceIdType": "UIN" +}' + auth_AuthTransaction_allValid_smoke_UIN5: + endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} + role: resident + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: ida/AuthTransaction/authTransaction + outputTemplate: ida/AuthTransaction/authTransactionResult + input: '{ + "individualId":"$ID:AddIdentity_Positive_EKYC_smoke_UIN$" +}' + output: '{ + "referenceIdType": "UIN" }' diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.hbs b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.hbs index 0b1191dfe4b..be6bbe32867 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.hbs +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.hbs @@ -4,4 +4,31 @@ }, "timestamp": "{{timestamp}}", "transactionID": "{{transactionId}}" +} + +{ + "demographics": { + "gender": [ + { + "language": "eng", + "value": "Male" + }, + { + "language": "ara", + "value": "ذكر" + } + ], + "residenceStatus": [ + { + "language": "eng", + "value": "Non-Foreigner" + }, + { + "language": "ara", + "value": "غير أجنبي" + } + ] + }, + "timestamp": "2021-10-04T10:24:53.250Z", + "transactionID": "1234567891" } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index 09548370bc2..e3f7b44f478 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -264,6 +264,150 @@ DemoAuthNew: }' output: '{ "authStatus": "true" +}' + auth_DemoAuth_gender_InValid_LangCode: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/error + input: '{ + "gender": [ + { + "language": "$123LANG$", + "value": "MLE" + } + ], + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuth_gender_InValid_Gender_Invalid_RS: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/error + input: '{ + "gender": [ + { + "language": "$PRIMARYLANG$", + "value": "M@@33E" + } + ], + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Ner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuth_gender_Valid_Gender_Invalid_RS: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/error + input: '{ + "gender": [ + { + "language": "$PRIMARYLANG$", + "value": "MLE" + } + ], + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Ner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuth_gender_InValid_Gender_valid_RS: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/error + input: '{ + "gender": [ + { + "language": "$PRIMARYLANG$", + "value": "ML@@#E" + } + ], + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Non-Foreigner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuth_gender_InValid_Gender_valid_RS_with_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/error + input: '{ + "gender": [ + { + "language": "$PRIMARYLANG$", + "value": "ML@@#E" + } + ], + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Non-Foreigner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuth_gender_Valid_Gender_valid_RS_with_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/error + input: '{ + "gender": [ + { + "language": "$PRIMARYLANG$", + "value": "MLE" + } + ], + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Non-Foreigner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "false" }' auth_DemoAuth_gender_InValid_Lang_Valid_Gender: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -302,6 +446,48 @@ DemoAuthNew: }' output: '{ "authStatus": "true" +}' + auth_DemoAuth_gender_Valid_Smoke_Pos_VID_with_RS_DOB: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/DemoAuthResult + input: '{ + "value": "1970/07/08", + "key": "dob", + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Non-Foreigner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "true" +}' + auth_DemoAuth_gender_Valid_Smoke_Pos_Temp_VID_with_RS_DOB: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Temp_VID_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoIdentityEncryptGender + outputTemplate: ida/DemoAuth/DemoAuthResult + input: '{ + "value": "1970/07/08", + "key": "dob", + "residenceStatus": [ + { + "language": "$PRIMARYLANG$", + "value": "Non-Foreigner" + } + ] + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "true" }' auth_DemoAuth_gender_InValid_LangCode_with_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ From 7459aaa827e0d5e4dd51de7d005cb94aebefd292 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 11 Sep 2023 23:24:05 +0530 Subject: [PATCH 136/204] MOSIP-29286 --- .../apirig/admin/fw/util/AdminTestUtil.java | 9 ++++++ .../ida/BlockHotlistAPI/BlockPartnerId.yml | 15 ++++++++++ .../HotlistTestcasesPartnerId.yml | 29 +++++++++++++++++++ 3 files changed, 53 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index f65f82b9db5..7658a376b3c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -2964,6 +2964,10 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (jsonString.contains("$APIKEY$")) { jsonString = replaceKeywordWithValue(jsonString, "$APIKEY$", getAPIKey()); } + + if (jsonString.contains("$MISPLICKEY$")) { + jsonString = replaceKeywordWithValue(jsonString, "$MISPLICKEY$", getMISPLICKey()); + } if (jsonString.contains("$IDENTITYJSON$")) { jsonString = replaceKeywordWithValue(jsonString, "$IDENTITYJSON$", generateIdentityJson(testCaseName)); @@ -3263,6 +3267,11 @@ public String getAPIKey() { String[] uriParts = PartnerRegistration.partnerKeyUrl.split("/"); return uriParts[uriParts.length - 1]; } + + public String getMISPLICKey() { + String[] uriParts = PartnerRegistration.partnerKeyUrl.split("/"); + return uriParts[0]; + } public String getAutoGenIdFileName(String testCaseName) { if (testCaseName == null) diff --git a/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockPartnerId.yml b/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockPartnerId.yml index e5ceed85fd2..6c600135ba5 100644 --- a/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockPartnerId.yml +++ b/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockPartnerId.yml @@ -29,3 +29,18 @@ HotlistAPI: output: '{ "status": "BLOCKED" }' + auth_BlockPartnerId_All_Valid_Smoke_block_MISP_LIC_key_sid: + endPoint: /v1/hotlist/block + role: hotlist + restMethod: post + inputTemplate: ida/BlockHotlistAPI/blockHotlistAPI + outputTemplate: ida/BlockHotlistAPI/blockHotlistAPIResult + input: '{ + "id": "$MISPLICKEY$", + "idType": "PARTNER_ID", + "requestTime": "$TIMESTAMP$", + "expiryTimestamp": "" + }' + output: '{ + "status": "BLOCKED" + }' diff --git a/automationtests/src/main/resources/ida/HotlistTestcases/HotlistTestcasesPartnerId.yml b/automationtests/src/main/resources/ida/HotlistTestcases/HotlistTestcasesPartnerId.yml index 11f0b9fc6fd..401c0562e03 100644 --- a/automationtests/src/main/resources/ida/HotlistTestcases/HotlistTestcasesPartnerId.yml +++ b/automationtests/src/main/resources/ida/HotlistTestcases/HotlistTestcasesPartnerId.yml @@ -27,4 +27,33 @@ DemoAuth: "errorMessage": "$IGNORE$" } ] +}' + auth_DemoAuth_blocked_partnerid__VID_Pos: + endPoint: /idauthentication/v1/auth/$partnerKeyURL$ + role: resident + restMethod: post + inputTemplate: ida/HotlistTestcases/hotlistTestcases + outputTemplate: ida/HotlistTestcases/HotlistTestcasesResult + input: '{ + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", + "transactionId": "$TRANSACTIONID$", + "individualIdType": "UIN", + "bio": false, + "demo": true, + "otp": false, + "identityRequest":{ + "value": "1970/07/08", +"key": "dob", + "identityRequestTemplate": "ida/HotlistTestcases/DemoIdentityEncrypt" + } + }' + output: '{ + "authStatus": false, + "errors": [ + { + "errorCode": "IDA-MLC-006", + "errorMessage": "$IGNORE$" + } + ] }' \ No newline at end of file From 90e256d5cb4e211a8ad0d9212cdaac1344df1b2c Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 12 Sep 2023 18:30:55 +0530 Subject: [PATCH 137/204] MOSIP-29379 --- .../apirig/admin/fw/util/AdminTestUtil.java | 2 + .../AuthenticateUserVCI.yml | 66 +++++++++++ .../AuthorizationCodeVCI.yml | 32 +++++ .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 40 +++++++ .../VCI/GetCredential/GetCredential.yml | 42 +++++++ .../OAuthDetailsRequestVCI.yml | 112 ++++++++++++++++++ 6 files changed, 294 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 7658a376b3c..fc7ddf999ea 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -454,6 +454,8 @@ protected Response postRequestWithCookieAuthHeaderAndXsrfToken(String url, Strin JSONObject requestInput = new JSONObject(inputJson); headers.put(cookieName, "Bearer " + requestInput.get(GlobalConstants.IDP_ACCESS_TOKEN).toString()); requestInput.remove(GlobalConstants.IDP_ACCESS_TOKEN); + if (requestInput.has("client_id")) + requestInput.remove("client_id"); inputJson = requestInput.toString(); } token = properties.getProperty(GlobalConstants.XSRFTOKEN); diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index b336e306111..d942d933545 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -294,4 +294,70 @@ AuthenticateUserVCI: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen1_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index e327fad317a..6f66ef2315f 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -165,4 +165,36 @@ AuthorizationCodeVCI: "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$" }' output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$" +}' + output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index 295ef1fbc14..d7418969d17 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -97,4 +97,44 @@ GenerateTokenVCI: }' output: '{ "error": "pkce_failed" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen1_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen1_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen2_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen2_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" +}' + output: '{ + "token_type": "Bearer" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index 6175039d860..81c3dbddd6e 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -17,4 +17,46 @@ GetCredential: "proof_jwt": "$PROOFJWT$" }' output: '{ +}' + + ESignet_GetCredential_uin_IdpAccessToken_NegCredScen1_Invalid_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen1_Smoke_sid_access_token$", + "format": "dfsfd", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "https://www.w3.org/2018/credentials/v1"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"unsupported_credential_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_NegCredScen2_Invalid_Proof_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen2_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "https://www.w3.org/2018/credentials/v1"}], + "proof_type": "jwt", + "proof_jwt": "wewrt" +}' + output: '{ + "error":"invalid_proof" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index 63393b046a1..de9a42fb3e3 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -485,4 +485,116 @@ OAuthDetailsRequestVCI: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Val_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "hafkja", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Missing_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "$REMOVE$", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallengeMethod": "S256" +}' + output: '{ + }' \ No newline at end of file From 91fcb0c9c6d8cc1b0a5b88c130ed74864bdb19ff Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 12 Sep 2023 19:05:12 +0530 Subject: [PATCH 138/204] MOSIP-29418 --- .../CreateDeviceSpecification.yml | 27 +++++++++++ .../DeviceType/CreateDeviceType.yml | 47 +++++++++++++++++++ .../CreateDocumentCategory.yml | 23 +++++++++ .../DocumentType/CreateDocumentType.yml | 23 +++++++++ .../CreateMachineSpecification.yml | 27 +++++++++++ .../MachineType/CreateMachineType.yml | 46 ++++++++++++++++++ .../RegCenterType/CreateRegCenterType.yml | 46 ++++++++++++++++++ 7 files changed, 239 insertions(+) diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml b/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml index 2841f97efd5..9cc1495dfcf 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml @@ -23,6 +23,33 @@ CreateDeviceSpecification: "langCode": "eng" }' + MasterData_CreateDeviceSpecification_Dublicate_DeviceSpecification_Neg: + endPoint: /v1/masterdata/devicespecifications + role: admin + templateFields: ["name","description"] + restMethod: post + inputTemplate: masterdata/DeviceSpecification/deviceSpecification + outputTemplate: masterdata/error + input: '{ + "brand": "hogwarts", + "description": "Test DeviceSpec", + "deviceTypeCode": "GST4", + "id": "743", + "isActive": true, + "langCode": "eng", + "minDriverversion": "1.0", + "model": "2020", + "name": "Face scanner", + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-999" + } + ] + }' + MasterData_CreateDeviceSpecification_InputParameter_Name_Missing: endPoint: /v1/masterdata/devicespecifications role: admin diff --git a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml index 0cc78b2cc06..68749a5e1c6 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml +++ b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml @@ -36,6 +36,30 @@ CreateDeviceType: output: '{ "code": "GST4", "langCode": "eng" +}' + + MasterData_CreateDeviceType_Dublicate_Device_Neg: + endPoint: /v1/masterdata/devicetypes + role: admin + templateFields: ["description"] + restMethod: post + inputTemplate: masterdata/DeviceType/deviceType + outputTemplate: masterdata/error + input: '{ + "code": "GST3", + "description": "test 1.0.8", + "isActive": true, + "langCode": "eng", + "name": "GST", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-053" + } + ] + }' MasterData_CreateDeviceType_InputParameter_Name_Missing: endPoint: /v1/masterdata/devicetypes @@ -150,4 +174,27 @@ CreateDeviceType: "message": "request.isActive: must not be null" } ] +}' + + MasterData_CreateDeviceType_Spacial_Character_Neg: + endPoint: /v1/masterdata/devicetypes + role: admin + templateFields: ["description","name"] + restMethod: post + inputTemplate: masterdata/DeviceType/deviceType + outputTemplate: masterdata/error + input: '{ + "code": "G@ST4", + "description": "$REMOVE$", + "isActive": true, + "langCode": "eng", + "name": "G@ST$4", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-999" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml b/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml index 703cb7688a5..d56e288060d 100644 --- a/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml +++ b/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml @@ -223,3 +223,26 @@ CreateDocumentCategory: } ] }' + + MasterData_CreateDocumentCategory_Spacial_Character_Neg: + endPoint: /v1/masterdata/documentcategories + role: admin + templateFields: ["name"] + restMethod: post + inputTemplate: masterdata/DocumentCategory/documentCategory + outputTemplate: masterdata/error + input: '{ + "code": "DocTestC@ode321", + "description": "$REMOVE$", + "isActive": true, + "langCode": "eng", + "name": "D@ocC$at", + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-999" + } + ] +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml b/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml index f4829dfdbe2..9b0b9f966ca 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml @@ -183,3 +183,26 @@ CreateDocumentType: } ] }' + + MasterData_CreateDocumentType_Spacial_Character_Neg: + endPoint: /v1/masterdata/documenttypes + role: admin + templateFields: ["name","description"] + restMethod: post + inputTemplate: masterdata/DocumentType/documentType + outputTemplate: masterdata/error + input: '{ + "code": "TestDoc@Type0010", + "description": "TestDocType0010 Card Holder", + "isActive": true, + "langCode": "eng", + "name": "TestDoc$Type@0010 Card", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-999" + } + ] +}' diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml b/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml index 8568837ca32..e67c9e45640 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml @@ -507,4 +507,31 @@ CreateMachineSpecification: "message": "request.isActive: must not be null" } ] +}' + + Masterdata_CreateMachineSpecification_Dublicate_Neg: + endPoint: /v1/masterdata/machinespecifications + role: admin + templateFields: ["description"] + restMethod: post + inputTemplate: masterdata/MachineSpecification/machineSpecification + outputTemplate: masterdata/error + input: '{ + "brand": "HP", + "description": "HP brand", + "id": "HP04", + "isActive": true, + "langCode": "eng", + "machineTypeCode": "Laptop2", + "minDriverversion": "3.2", + "model": "1234", + "name": "HP", + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-061" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml b/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml index 2bb7525cdef..290dd38c154 100644 --- a/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml +++ b/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml @@ -177,4 +177,50 @@ CreateMachineType: "message": "request.isActive: must not be null" } ] +}' + + Masterdata_CreateMachineType_With_Spacial_Characters_Neg: + endPoint: /v1/masterdata/machinetypes + role: admin + templateFields: ["description","name"] + restMethod: post + inputTemplate: masterdata/MachineType/machineType + outputTemplate: masterdata/error + input: '{ + "code": "L@apto@p2", + "description": "Lapto@p2 info", + "isActive": true, + "langCode": "eng", + "name": "Lap$top2 test", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-999" + } + ] +}' + + Masterdata_CreateMachineType_Dublicate_Neg: + endPoint: /v1/masterdata/machinetypes + role: admin + templateFields: ["description","name"] + restMethod: post + inputTemplate: masterdata/MachineType/machineType + outputTemplate: masterdata/error + input: '{ + "code": "Laptop2", + "description": "Laptop2 info", + "isActive": true, + "langCode": "eng", + "name": "Laptop2 test", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-061" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterType/CreateRegCenterType.yml b/automationtests/src/main/resources/masterdata/RegCenterType/CreateRegCenterType.yml index a16b6638a18..8930c30308f 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterType/CreateRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/RegCenterType/CreateRegCenterType.yml @@ -18,6 +18,29 @@ CreateRegCenterType: "code": "ALT-3", "langCode": "eng" }' + + MasterData_CreateRegCenterType_Dublicate_Centertype_Neg: + endPoint: /v1/masterdata/registrationcentertypes + role: admin + templateFields: ["name","descr"] + restMethod: post + inputTemplate: masterdata/RegCenterType/regCenterType + outputTemplate: masterdata/error + input: '{ + "code": "ALT-3", + "langCode": "eng", + "name": "alternate", + "descr": "alternate center", + "isActive":true, + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-101" + } + ] +}' MasterData_CreateRegCenterType_InputParameter_Name_Missing: @@ -136,4 +159,27 @@ CreateRegCenterType: "message": "request.isActive: must not be null" } ] +}' + + MasterData_CreateRegCenterType_SpacialCharacter_Neg: + endPoint: /v1/masterdata/registrationcentertypes + role: admin + templateFields: ["name","descr"] + restMethod: post + inputTemplate: masterdata/RegCenterType/regCenterType + outputTemplate: masterdata/error + input: '{ + "code": "A@LT-3", + "langCode": "eng", + "name": "alt$er@nate", + "descr": "alt@ernate center", + "isActive":true, + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-999" + } + ] }' \ No newline at end of file From 1d8d344280fa83fc08ff97d7b01dcfa0332dbac8 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 12 Sep 2023 19:09:52 +0530 Subject: [PATCH 139/204] MOSIP-29418 --- .../MachineSpecification/CreateMachineSpecification.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml b/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml index e67c9e45640..0a75e432713 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml @@ -531,7 +531,7 @@ CreateMachineSpecification: output: '{ "errors": [ { - "errorCode": "KER-MSD-061" + "errorCode": "KER-MSD-999" } ] }' \ No newline at end of file From 8f05ad4a7aa0108b2136007388b5d714bd40cf9f Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 13 Sep 2023 15:31:01 +0530 Subject: [PATCH 140/204] MOSIP-29332 --- .../apirig/admin/fw/util/AdminTestUtil.java | 412 +++++++++--------- 1 file changed, 211 insertions(+), 201 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 7658a376b3c..f12345af23a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -142,7 +142,7 @@ public class AdminTestUtil extends BaseTestCase { public static String propsHealthCheckURL = MosipTestRunner.getGlobalResourcePath() + "/" + "config/healthCheckEndpoint.properties"; private static String serverComponentsCommitDetails; - + String token = null; String idToken = null; String adminAutoGeneratedIdPropFileName = properties.getProperty("adminAutoGeneratedIdPropFileName"); @@ -219,7 +219,7 @@ public static BioDataUtility getBioDataUtil() { getResourcePath() + "BINDINGCERTCONSENTSAMECLAIMFile.txt"); private static File bindingCertConsentVidSameClaimFile = new File( getResourcePath() + "BINDINGCERTCONSENTVIDSAMECLAIMFile.txt"); - + private static final String UIN_CODE_VERIFIER_POS_1 = generateRandomAlphaNumericString(GlobalConstants.INTEGER_36); /** The Constant SIGN_ALGO. */ @@ -295,7 +295,7 @@ private static void settriggerESignetKeyGen7(boolean value) { private static boolean gettriggerESignetKeyGen7() { return triggerESignetKeyGen7; } - + protected static boolean triggerESignetKeyGen8 = true; private static void settriggerESignetKeyGen8(boolean value) { @@ -305,7 +305,7 @@ private static void settriggerESignetKeyGen8(boolean value) { private static boolean gettriggerESignetKeyGen8() { return triggerESignetKeyGen8; } - + public static void setLogLevel() { if (ConfigManager.IsDebugEnabled()) logger.setLevel(Level.ALL); @@ -353,14 +353,13 @@ protected Response postWithBodyAndCookie(String url, String jsonInput, boolean a token = kernelAuthLib.getTokenByRole(role, ACCESSTOKENCOOKIENAME); idToken = kernelAuthLib.getTokenByRole(role, IDTOKENCOOKIENAME); } else { - - if(testCaseName.contains("NOAUTH")){ - token=""; - } - else { + + if (testCaseName.contains("NOAUTH")) { + token = ""; + } else { token = kernelAuthLib.getTokenByRole(role); } - + } logger.info(GlobalConstants.POST_REQ_URL + url); GlobalMethods.reportRequest(null, inputJson); @@ -596,20 +595,15 @@ public static void getFileNameToWrite(Response response, String testCaseName) { File fileName = null; if (testCaseName.contains("Wla_uin_")) { fileName = bindingCertFile; - } - else if (testCaseName.contains("Wla_vid_")) { + } else if (testCaseName.contains("Wla_vid_")) { fileName = bindingCertFileVid; - } - else if (testCaseName.contains("_Consentuin_")) { + } else if (testCaseName.contains("_Consentuin_")) { fileName = bindingCertConsentFile; - } - else if (testCaseName.contains("_ConsentVid_")) { + } else if (testCaseName.contains("_ConsentVid_")) { fileName = bindingCertConsentVidFile; - } - else if (testCaseName.contains("_Consent_SameClaim_uin_")) { + } else if (testCaseName.contains("_Consent_SameClaim_uin_")) { fileName = bindingCertConsentSameClaimFile; - } - else if (testCaseName.contains("_Consent_SameClaim_Vid_")) { + } else if (testCaseName.contains("_Consent_SameClaim_Vid_")) { fileName = bindingCertConsentVidSameClaimFile; } @@ -704,10 +698,9 @@ protected Response postRequestWithCookieAuthHeaderAndSignature(String url, Strin headers.put(AUTHORIZATHION_HEADERNAME, AUTH_HEADER_VALUE); String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); headers.put(SIGNATURE_HEADERNAME, generateSignatureWithRequest(inputJson, partnerId)); - if(testCaseName.contains("NOAUTH")){ - token=""; - } - else { + if (testCaseName.contains("NOAUTH")) { + token = ""; + } else { token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); @@ -769,15 +762,13 @@ protected Response postRequestWithAuthHeaderAndSignature(String url, String json HashMap headers = new HashMap<>(); headers.put(AUTHORIZATHION_HEADERNAME, AUTH_HEADER_VALUE); String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); - - if(testCaseName.contains("NOAUTH")){ + + if (testCaseName.contains("NOAUTH")) { headers.put(SIGNATURE_HEADERNAME, ""); - } - else { + } else { headers.put(SIGNATURE_HEADERNAME, generateSignatureWithRequest(inputJson, partnerId)); } - - + logger.info(GlobalConstants.POST_REQ_URL + url); GlobalMethods.reportRequest(headers.toString(), inputJson); try { @@ -2404,7 +2395,7 @@ void writeAutoGeneratedIdForKeyCloak(Response response, String idKeyName, String // logger.error("Exception while getting autogenerated id and writing in property file:" + e.getMessage()); // } // } - + public void writeAutoGeneratedId(String testCaseName, String idName, String value) { if (testCaseName == null || idName == null || value == null) { logger.error("autogenerated id is not stored as few details not available"); @@ -2424,7 +2415,7 @@ public void writeAutoGeneratedId(String testCaseName, String idName, String valu logger.info("added autogenerated fields to property: " + getResourcePath() + fileName); } catch (JSONException | IOException e) { logger.error("Exception while getting autogenerated id and writing in property file:" + e.getMessage()); - }finally { + } finally { closeInputStream(inputStream); closeOutputStream(outputStream); } @@ -2481,9 +2472,9 @@ public static void copymoduleSpecificAndConfigFile(String moduleName) { ExtractResource.getListOfFilesFromJarAndCopyToExternalResource(moduleName + "/"); } else { try { - File destination = new File( - RunConfigUtil.getGlobalResourcePath()); - File source = new File(RunConfigUtil.getGlobalResourcePath().replace("MosipTestResource/MosipTemporaryTestResource", "") + moduleName); + File destination = new File(RunConfigUtil.getGlobalResourcePath()); + File source = new File(RunConfigUtil.getGlobalResourcePath() + .replace("MosipTestResource/MosipTemporaryTestResource", "") + moduleName); FileUtils.copyDirectoryToDirectory(source, destination); // source = new File(RunConfigUtil.getGlobalResourcePath() + "/config"); @@ -2548,22 +2539,21 @@ public Object[] getYmlTestData(String ymlPath) { @SuppressWarnings("unchecked") protected Map>> loadyaml(String path) { - Map>> scriptsMap = null; + Map>> scriptsMap = null; FileInputStream inputStream = null; BufferedInputStream bufferedInput = null; int customBufferSize = 16384; // 16 KB - try { + try { inputStream = new FileInputStream(new File(getResourcePath() + path).getAbsoluteFile()); - bufferedInput = new BufferedInputStream(inputStream, customBufferSize); - Yaml yaml = new Yaml(); - scriptsMap = yaml.loadAs(bufferedInput, Map.class); - } catch (Exception e) { - logger.error("Error loading YAML: " + e.getMessage()); - } - finally { + bufferedInput = new BufferedInputStream(inputStream, customBufferSize); + Yaml yaml = new Yaml(); + scriptsMap = yaml.loadAs(bufferedInput, Map.class); + } catch (Exception e) { + logger.error("Error loading YAML: " + e.getMessage()); + } finally { closeInputStream(inputStream); } - return scriptsMap; + return scriptsMap; } // @SuppressWarnings("unchecked") @@ -2587,7 +2577,7 @@ public String getJsonFromTemplate(String input, String template) { return getJsonFromTemplate(input, template, true); } - + public static Handlebars handlebars = new Handlebars(); public static Gson gson = new Gson(); @@ -2669,9 +2659,9 @@ public String uriKeyWordHandelerUri(String uri, String testCaseName) { return uri; } - + public String replaceKeywordWithValue(String jsonString, String keyword, String value) { - if (value != null && !value.isEmpty()) + if (value != null && !value.isEmpty()) return jsonString.replace(keyword, value); else throw new SkipException("Marking testcase as skipped as required fields are empty " + keyword); @@ -2694,14 +2684,16 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.MODULENAME, BaseTestCase.certsForModule); } if (jsonString.contains(GlobalConstants.CERTSDIR)) { - jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.CERTSDIR, ConfigManager.getauthCertsPath()); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.CERTSDIR, + ConfigManager.getauthCertsPath()); } if (jsonString.contains("$BIOVALUE$")) { jsonString = replaceKeywordWithValue(jsonString, "$BIOVALUE$", propsBio.getProperty("BioValue")); } if (jsonString.contains("$BIOVALUEWITHOUTFACE$")) { - jsonString = replaceKeywordWithValue(jsonString, "$BIOVALUEWITHOUTFACE$", propsBio.getProperty("BioValueWithoutFace")); + jsonString = replaceKeywordWithValue(jsonString, "$BIOVALUEWITHOUTFACE$", + propsBio.getProperty("BioValueWithoutFace")); } if (jsonString.contains("$CLAIMSFROMCONFIG$")) jsonString = replaceKeywordWithValue(jsonString, "$CLAIMSFROMCONFIG$", getValueFromConfigActuator()); @@ -2726,9 +2718,11 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$3RDLANG$", BaseTestCase.languageList.get(2)); if (jsonString.contains(GlobalConstants.KEYCLOAK_USER_1)) - jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.KEYCLOAK_USER_1, propsKernel.getProperty("KEYCLOAKUSER1")); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.KEYCLOAK_USER_1, + propsKernel.getProperty("KEYCLOAKUSER1")); if (jsonString.contains(GlobalConstants.KEYCLOAK_USER_2)) - jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.KEYCLOAK_USER_2, propsKernel.getProperty("KEYCLOAKUSER2")); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.KEYCLOAK_USER_2, + propsKernel.getProperty("KEYCLOAKUSER2")); if (jsonString.contains("$RIDDEL$")) jsonString = replaceKeywordWithValue(jsonString, "$RIDDEL$", genRidDel); if (jsonString.contains("$ID:")) { @@ -2797,7 +2791,8 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$MISPPOLICYNAME$", genMispPolicyName); if (jsonString.contains("$RANDOMPOLICYNAME$")) - jsonString = replaceKeywordWithValue(jsonString, "$RANDOMPOLICYNAME$", generateRandomAlphaNumericString(15)); + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMPOLICYNAME$", + generateRandomAlphaNumericString(15)); if (jsonString.contains("$RANDOMPARTNERID$")) jsonString = replaceKeywordWithValue(jsonString, "$RANDOMPARTNERID$", generateRandomAlphaNumericString(15)); @@ -2807,28 +2802,23 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (jsonString.contains("$MISPPARTNEREMAIL$")) jsonString = replaceKeywordWithValue(jsonString, "$MISPPARTNEREMAIL$", genMispPartnerEmail); - - + if (jsonString.contains("$ZONE_CODE$")) jsonString = replaceKeywordWithValue(jsonString, "$ZONE_CODE$", ZonelocationCode); - + if (jsonString.contains("$LOCATIONCODE$")) jsonString = replaceKeywordWithValue(jsonString, "$LOCATIONCODE$", locationCode); - - - //Need to handle int replacement - //if (jsonString.contains("$HIERARCHYLEVEL$")) - //jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYLEVEL$", hierarchyLevel); - + + // Need to handle int replacement + // if (jsonString.contains("$HIERARCHYLEVEL$")) + // jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYLEVEL$", + // hierarchyLevel); + if (jsonString.contains("$HIERARCHYNAME$")) jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYNAME$", hierarchyName); - + if (jsonString.contains("$PARENTLOCCODE$")) jsonString = replaceKeywordWithValue(jsonString, "$PARENTLOCCODE$", parentLocCode); - - - - if (jsonString.contains("$CACERT$")) { JSONObject request = new JSONObject(jsonString); @@ -2956,7 +2946,8 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { publickey = JsonPrecondtion.getJsonValueFromJson(jsonString, "request.publicKey"); } if (jsonString.contains("$PUBLICKEYFORBINDING$")) { - jsonString = replaceKeywordWithValue(jsonString, "$PUBLICKEYFORBINDING$", MosipTestRunner.generatePublicKeyForMimoto()); + jsonString = replaceKeywordWithValue(jsonString, "$PUBLICKEYFORBINDING$", + MosipTestRunner.generatePublicKeyForMimoto()); } if (jsonString.contains(GlobalConstants.PARTNER_ID)) { jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.PARTNER_ID, getPartnerId()); @@ -2964,7 +2955,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (jsonString.contains("$APIKEY$")) { jsonString = replaceKeywordWithValue(jsonString, "$APIKEY$", getAPIKey()); } - + if (jsonString.contains("$MISPLICKEY$")) { jsonString = replaceKeywordWithValue(jsonString, "$MISPLICKEY$", getMISPLICKey()); } @@ -3056,7 +3047,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTSAMECLAIMJWKKEY$", jwkKey); } - + if (jsonString.contains("$BINDINGCONSENTSAMECLAIMVIDJWKKEY$")) { String jwkKey = ""; if (gettriggerESignetKeyGen8()) { @@ -3104,7 +3095,8 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (request.has("client_id")) { clientId = request.get("client_id").toString(); } - jsonString = replaceKeywordWithValue(jsonString, "$CLIENT_ASSERTION_JWK$", signJWKKey(clientId, oidcJWKKey1)); + jsonString = replaceKeywordWithValue(jsonString, "$CLIENT_ASSERTION_JWK$", + signJWKKey(clientId, oidcJWKKey1)); } if (jsonString.contains("$IDPCLIENTPAYLOAD$")) { String clientId = getValueFromActuator(GlobalConstants.RESIDENT_DEFAULT_PROPERTIES, @@ -3127,11 +3119,13 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { payloadBody.put("exp", epochValue + idTokenExpirySecs); payloadBody.put("iat", epochValue); - jsonString = replaceKeywordWithValue(jsonString, "$IDPCLIENTPAYLOAD$", encodeBase64(payloadBody.toString())); + jsonString = replaceKeywordWithValue(jsonString, "$IDPCLIENTPAYLOAD$", + encodeBase64(payloadBody.toString())); } if (jsonString.contains("$WLATOKEN$")) { - jsonString = replaceKeywordWithValue(jsonString, "$WLATOKEN$", generateWLAToken(jsonString, bindingJWK1, bindingCertFile)); + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKEN$", + generateWLAToken(jsonString, bindingJWK1, bindingCertFile)); } if (jsonString.contains("$WLATOKENVID$")) { @@ -3158,15 +3152,16 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTVIDSAMECLAIM$", generateWLAToken(jsonString, bindingConsentVidSameClaimJWK, bindingCertConsentVidSameClaimFile)); } - + if (jsonString.contains("$UINCODECHALLENGEPOS1$")) { - jsonString = replaceKeywordWithValue(jsonString, "$UINCODECHALLENGEPOS1$", GlobalMethods.sha256(UIN_CODE_VERIFIER_POS_1)); + jsonString = replaceKeywordWithValue(jsonString, "$UINCODECHALLENGEPOS1$", + GlobalMethods.sha256(UIN_CODE_VERIFIER_POS_1)); } - + if (jsonString.contains("$UINCODEVERIFIERPOS1$")) { jsonString = replaceKeywordWithValue(jsonString, "$UINCODEVERIFIERPOS1$", UIN_CODE_VERIFIER_POS_1); } - + if (jsonString.contains("$PROOFJWT$")) { String oidcJWKKeyString = getJWKKey(oidcJWK1); @@ -3197,7 +3192,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { return jsonString; } - + public static String signJWK(String clientId, String accessToken, RSAKey jwkKey) { String tempUrl = getValueFromActuator(GlobalConstants.RESIDENT_DEFAULT_PROPERTIES, "mosip.iam.base.url"); int idTokenExpirySecs = Integer.parseInt(getValueFromEsignetActuator(GlobalConstants.ESIGNET_DEFAULT_PROPERTIES, @@ -3207,20 +3202,18 @@ public static String signJWK(String clientId, String accessToken, RSAKey jwkKey) try { signer = new RSASSASigner(jwkKey); - - String[] jwtParts = accessToken.split("\\."); - String jwtPayloadBase64 = jwtParts[1]; - byte[] jwtPayloadBytes = Base64.getDecoder().decode(jwtPayloadBase64); - String jwtPayload = new String(jwtPayloadBytes, StandardCharsets.UTF_8); - - JWTClaimsSet claimsSet = new JWTClaimsSet.Builder() - .audience(tempUrl) - .claim("nonce", new ObjectMapper().readTree(jwtPayload).get("c_nonce").asText()) - .issuer(clientId) + + String[] jwtParts = accessToken.split("\\."); + String jwtPayloadBase64 = jwtParts[1]; + byte[] jwtPayloadBytes = Base64.getDecoder().decode(jwtPayloadBase64); + String jwtPayload = new String(jwtPayloadBytes, StandardCharsets.UTF_8); + + JWTClaimsSet claimsSet = new JWTClaimsSet.Builder().audience(tempUrl) + .claim("nonce", new ObjectMapper().readTree(jwtPayload).get("c_nonce").asText()).issuer(clientId) .issueTime(new Date()).expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); - SignedJWT signedJWT = new SignedJWT( - new JWSHeader.Builder(JWSAlgorithm.RS256).type(new JOSEObjectType("openid4vci-proof+jwt")).jwk(jwkKey.toPublicJWK()).build(), claimsSet); + SignedJWT signedJWT = new SignedJWT(new JWSHeader.Builder(JWSAlgorithm.RS256) + .type(new JOSEObjectType("openid4vci-proof+jwt")).jwk(jwkKey.toPublicJWK()).build(), claimsSet); signedJWT.sign(signer); proofJWT = signedJWT.serialize(); @@ -3267,7 +3260,7 @@ public String getAPIKey() { String[] uriParts = PartnerRegistration.partnerKeyUrl.split("/"); return uriParts[uriParts.length - 1]; } - + public String getMISPLICKey() { String[] uriParts = PartnerRegistration.partnerKeyUrl.split("/"); return uriParts[0]; @@ -3596,7 +3589,7 @@ private static File updateCSV(String fileToUpdate, String replace, int row, int public static Properties getproperty(String path) { Properties prop = new Properties(); - try(FileInputStream inputStream = new FileInputStream(path);) { + try (FileInputStream inputStream = new FileInputStream(path);) { // File file = new File(path); // inputStream = new FileInputStream(file); prop.load(inputStream); @@ -4004,7 +3997,6 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { FileWriter fileWriter3 = null; FileReader fileReader = null; BufferedReader bufferedReader = null; - String mobileno = "7019858531"; try { JSONObject jObj = new JSONObject(schemaFile); @@ -4012,10 +4004,11 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { JSONObject objIDJson = objIDJson4.getJSONObject(GlobalConstants.IDENTITY); JSONObject objIDJson2 = objIDJson.getJSONObject(GlobalConstants.PROPERTIES); JSONArray objIDJson1 = objIDJson.getJSONArray(GlobalConstants.REQUIRED); - if (!isTargetEnvLTS()) { - objIDJson1.put("mobileno"); - objIDJson1.put("email"); - } + + // if (!isTargetEnvLTS()) { + objIDJson1.put(getValueFromAuthActuator("json-property", "phone_number")); + objIDJson1.put(getValueFromAuthActuator("json-property", "emailId")); + // } fileWriter1 = new FileWriter(GlobalConstants.ADDIDENTITY_HBS); fileWriter1.write("{\n"); fileWriter1.write(" \"id\": \"{{id}}\",\n"); @@ -4044,17 +4037,14 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { studentJSON.put(GlobalConstants.LANGUAGE, BaseTestCase.getLanguageList().get(j)); if (objIDJson3.contains(GlobalConstants.FULLNAME) && regenerateHbs == true) { studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3 + "1")); // fullName1 - } - else if (objIDJson3.contains(GlobalConstants.FIRST_NAME) && regenerateHbs == true) { + } else if (objIDJson3.contains(GlobalConstants.FIRST_NAME) && regenerateHbs == true) { studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3 + 1)); // fullName1 - } - else if (objIDJson3.contains(GlobalConstants.GENDER)) { + } else if (objIDJson3.contains(GlobalConstants.GENDER)) { studentJSON.put(GlobalConstants.VALUE, propsMap.getProperty(objIDJson3)); - } - else { - studentJSON.put(GlobalConstants.VALUE, - (propsMap.getProperty(objIDJson3) == null) ? "TEST_"+objIDJson3 - : propsMap.getProperty(objIDJson3)+ BaseTestCase.getLanguageList().get(j)); + } else { + studentJSON.put(GlobalConstants.VALUE, (propsMap.getProperty(objIDJson3) == null) + ? "TEST_" + objIDJson3 + : propsMap.getProperty(objIDJson3) + BaseTestCase.getLanguageList().get(j)); } jArray.put(studentJSON); } @@ -4083,21 +4073,21 @@ else if (objIDJson3.contains(GlobalConstants.GENDER)) { fileWriter2.write("\t \"proofOfIdentity\": {\n" + "\t\t\"format\": \"txt\",\n" + "\t\t\"type\": \"DOC001\",\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t },\n"); } - - else if (objIDJson3.equals("mobileno")) { - fileWriter2.write(",\t \"" + objIDJson3 + "\":" + " " + "\"" + mobileno + "\"" + "\n"); + + else if (objIDJson3.equals(getValueFromAuthActuator("json-property", "phone_number"))) { + fileWriter2 + .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); } - - else if (objIDJson3.equals("email") && !isTargetEnvLTS()) { + + else if (objIDJson3.equals(getValueFromAuthActuator("json-property", "emailId"))) { fileWriter2 - .write(",\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + "\n"); + .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); } else if (objIDJson3.equals(GlobalConstants.INDIVIDUALBIOMETRICS)) { fileWriter2.write("\t \"individualBiometrics\": {\n" + "\t\t\"format\": \"cbeff\",\n" + "\t\t\"version\": 1,\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t }\n"); - } - else if (objIDJson3.equals(GlobalConstants.PROOF_OF_ADDRESS)) { + } else if (objIDJson3.equals(GlobalConstants.PROOF_OF_ADDRESS)) { fileWriter2.write("\t \"proofOfAddress\": {\n" + "\t\t\"format\": \"txt\",\n" + "\t\t\"type\": \"DOC001\",\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t },\n"); } @@ -4107,7 +4097,8 @@ else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { } else { - fileWriter2.write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + fileWriter2 + .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); } fileWriter2.close(); @@ -4238,9 +4229,9 @@ public static String generateHbsForUpdateDraft() { JSONObject studentJSON = new JSONObject(); studentJSON.put(GlobalConstants.LANGUAGE, BaseTestCase.getLanguageList().get(j)); studentJSON.put(GlobalConstants.VALUE, - (propsMap.getProperty(objIDJson3) == null) ? "TEST_"+objIDJson3 + (propsMap.getProperty(objIDJson3) == null) ? "TEST_" + objIDJson3 : propsMap.getProperty(objIDJson3)); - + jArray.put(studentJSON); } } @@ -4425,7 +4416,7 @@ public static String generateHbsForPrereg(boolean isItUpdate) { JSONObject studentJSON = new JSONObject(); studentJSON.put(GlobalConstants.LANGUAGE, BaseTestCase.getLanguageList().get(j)); studentJSON.put(GlobalConstants.VALUE, - (propsMap.getProperty(objIDJson3) == null) ? "TEST_"+objIDJson3 + (propsMap.getProperty(objIDJson3) == null) ? "TEST_" + objIDJson3 : propsMap.getProperty(objIDJson3)); jArray.put(studentJSON); } @@ -4522,9 +4513,10 @@ else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { @SuppressWarnings("unchecked") public static void createAndPublishPolicy() { if (!BaseTestCase.isTargetEnvLTS()) { - // In case of 1.1.5 we don't have auto sync of certificates between Key manager cert store and IDA cert store + // In case of 1.1.5 we don't have auto sync of certificates between Key manager + // cert store and IDA cert store // So use the predefined certificate folder and partner key - return ; + return; } String token = kernelAuthLib.getTokenByRole(GlobalConstants.PARTNER); @@ -4594,9 +4586,7 @@ public static String signJWKKey(String clientId, RSAKey jwkKey) { try { signer = new RSASSASigner(jwkKey); - JWTClaimsSet claimsSet = new JWTClaimsSet.Builder().subject(clientId) - .audience(tempUrl) - .issuer(clientId) + JWTClaimsSet claimsSet = new JWTClaimsSet.Builder().subject(clientId).audience(tempUrl).issuer(clientId) .issueTime(new Date()).expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); SignedJWT signedJWT = new SignedJWT( @@ -4664,16 +4654,13 @@ public static Certificate convertToCertificate(String certData) { return null; } } - - - private static String otpExpTime = ""; public static int getOtpExpTimeFromActuator() { if (otpExpTime.isEmpty()) { String section = "configService:https://github.com/mosip/mosip-config/application-default.properties"; - if (!BaseTestCase.isTargetEnvLTS()) + if (!BaseTestCase.isTargetEnvLTS()) section = "configService:https://github.com/mosip/mosip-config/sandbox/application-lts.properties"; Response response = null; org.json.JSONObject responseJson = null; @@ -4740,8 +4727,38 @@ public static String getValueFromEsignetActuator(String section, String key) { Response response = null; JSONObject responseJson = null; JSONArray responseArray = null; - String url = ConfigManager.getEsignetBaseUrl() - + propsKernel.getProperty("actuatorEsignetEndpoint"); + String url = ConfigManager.getEsignetBaseUrl() + propsKernel.getProperty("actuatorEsignetEndpoint"); + String value = null; + try { + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); + + responseJson = new JSONObject(response.getBody().asString()); + responseArray = responseJson.getJSONArray("propertySources"); + + for (int i = 0, size = responseArray.length(); i < size; i++) { + JSONObject eachJson = responseArray.getJSONObject(i); + if (eachJson.get("name").toString().contains(section)) { + value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) + .get(GlobalConstants.VALUE).toString(); + break; + } + } + + return value; + } catch (Exception e) { + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); + return value; + } + + } + + public static String getValueFromAuthActuator(String section, String key) { + + Response response = null; + JSONObject responseJson = null; + JSONArray responseArray = null; + String url = ConfigManager.getEsignetBaseUrl() + propsKernel.getProperty("actuatorIDAEndpoint"); String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); @@ -4838,7 +4855,7 @@ public static String isTestCaseValidForExecution(TestCaseDTO testCaseDTO) { && testCaseName.contains("_SignJWT_")) { throw new SkipException("esignet module is not deployed"); } - + if ((!ConfigManager.IseSignetDeployed()) && BaseTestCase.currentModule.equalsIgnoreCase("resident") && (testCaseDTO.getRole() != null && (testCaseDTO.getRole().equalsIgnoreCase("residentNew") || testCaseDTO.getRole().equalsIgnoreCase("residentNewVid")))) { @@ -5076,22 +5093,22 @@ public static void checkDbAndValidate(String timeStamp, String dbChecker) throws throw new AdminTestException("Failed at output validation"); Reporter.log(ReportUtil.getOutputValidationReport(objMap)); } - + public static String getPartnerIdFromPartnerURL(String partnerKeyURLSuffix) { - Pattern pattern = Pattern.compile("/(.*?)/"); - Matcher matcher = pattern.matcher(partnerKeyURLSuffix); - String substring = ""; - if (matcher.find()) { - substring = matcher.group(1); - } - System.out.println(substring); // substring - return substring; - } - + Pattern pattern = Pattern.compile("/(.*?)/"); + Matcher matcher = pattern.matcher(partnerKeyURLSuffix); + String substring = ""; + if (matcher.find()) { + substring = matcher.group(1); + } + System.out.println(substring); // substring + return substring; + } + public static String getServerComponentsDetails() { if (serverComponentsCommitDetails != null && !serverComponentsCommitDetails.isEmpty()) return serverComponentsCommitDetails; - + File file = new File(propsHealthCheckURL); FileReader fileReader = null; BufferedReader bufferedReader = null; @@ -5106,8 +5123,9 @@ public static String getServerComponentsDetails() { continue; String[] parts = line.trim().split("="); if (parts.length > 1) { - - stringBuilder.append("\n").append(getCommitDetails(BaseTestCase.ApplnURI + parts[1].replace("health", "info"))); + + stringBuilder.append("\n") + .append(getCommitDetails(BaseTestCase.ApplnURI + parts[1].replace("health", "info"))); } } } catch (Exception e) { @@ -5119,7 +5137,7 @@ public static String getServerComponentsDetails() { serverComponentsCommitDetails = stringBuilder.toString(); return serverComponentsCommitDetails; } - + public static String getCommitDetails(String path) { Response response = null; @@ -5127,99 +5145,92 @@ public static String getCommitDetails(String path) { if (response != null && response.getStatusCode() == 200) { logger.info(response.getBody().asString()); JSONObject jsonResponse = new JSONObject(response.getBody().asString()); - return "Group: " + jsonResponse.getJSONObject("build").getString("group") + ", Artifact: " + jsonResponse.getJSONObject("build").getString("artifact") + ", version: " - + jsonResponse.getJSONObject("build").getString("version") + ", Commit ID: " + jsonResponse.getJSONObject("git").getJSONObject("commit").getString("id"); + return "Group: " + jsonResponse.getJSONObject("build").getString("group") + ", Artifact: " + + jsonResponse.getJSONObject("build").getString("artifact") + ", version: " + + jsonResponse.getJSONObject("build").getString("version") + ", Commit ID: " + + jsonResponse.getJSONObject("git").getJSONObject("commit").getString("id"); } return path + "- No Response"; } - + public static void getLocationData() { - + Response response = null; JSONObject responseJson = null; String url = ApplnURI + props.getProperty("fetchLocationData"); String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); try { - response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, - MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, + GlobalConstants.AUTHORIZATION, token); responseJson = new JSONObject(response.getBody().asString()); - + try { JSONObject responseObject = responseJson.getJSONObject("response"); - JSONArray data = responseObject.getJSONArray("data"); + JSONArray data = responseObject.getJSONArray("data"); + for (int i = 0; i < data.length(); i++) { + JSONObject entry = data.getJSONObject(i); + String langCode = entry.getString("langCode"); - - for (int i = 0; i < data.length(); i++) { - JSONObject entry = data.getJSONObject(i); - String langCode = entry.getString("langCode"); - - if (BaseTestCase.languageList.get(0).equals(langCode)) { - hierarchyName = entry.getString("hierarchyName"); - hierarchyLevel = entry.getInt("hierarchyLevel"); - parentLocCode = entry.optString("parentLocCode", ""); - break; - } - } - + if (BaseTestCase.languageList.get(0).equals(langCode)) { + hierarchyName = entry.getString("hierarchyName"); + hierarchyLevel = entry.getInt("hierarchyLevel"); + parentLocCode = entry.optString("parentLocCode", ""); + break; + } + } } catch (Exception e) { logger.error(e.getMessage()); } - } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); } } - - -public static void getLocationLevelData() { - - Response response = null; - JSONObject responseJson = null; - String url = ApplnURI + props.getProperty("fetchLocationLevel") + BaseTestCase.getLanguageList().get(0); - String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); - - - try { - response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, - GlobalConstants.AUTHORIZATION, token); + public static void getLocationLevelData() { - responseJson = new JSONObject(response.getBody().asString()); + Response response = null; + JSONObject responseJson = null; + String url = ApplnURI + props.getProperty("fetchLocationLevel") + BaseTestCase.getLanguageList().get(0); + String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); try { - JSONObject responseObject = responseJson.getJSONObject("response"); - JSONArray data = responseObject.getJSONArray("locations"); - JSONObject entry = data.getJSONObject(0); - locationCode = entry.getString("code"); + response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, + GlobalConstants.AUTHORIZATION, token); + + responseJson = new JSONObject(response.getBody().asString()); + + try { + JSONObject responseObject = responseJson.getJSONObject("response"); + JSONArray data = responseObject.getJSONArray("locations"); + + JSONObject entry = data.getJSONObject(0); + locationCode = entry.getString("code"); + + } catch (Exception e) { + logger.error(e.getMessage()); + } } catch (Exception e) { - logger.error(e.getMessage()); + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); } - - } catch (Exception e) { - logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); - } } - public static void getZoneName() { Response response = null; JSONObject responseJson = null; String url = ApplnURI + props.getProperty("fetchZone"); String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); - - + Map map = new HashMap<>(); - + map.put("langCode", BaseTestCase.getLanguageList().get(0)); - map.put("userID", "masterdata-"+ConfigManager.getUserAdminName()); - + map.put("userID", "masterdata-" + ConfigManager.getUserAdminName()); try { @@ -5241,7 +5252,7 @@ public static void getZoneName() { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); } } - + public static String inputTitleHandler(String jsonString) { Response response = null; JSONObject responseJson = null; @@ -5255,9 +5266,9 @@ public static String inputTitleHandler(String jsonString) { if (nameArray.length() > 0) { JSONObject nameObject = nameArray.getJSONObject(0); value = nameObject.getString("value"); - firstWord = value.split("\\s+")[0]; //Miss-TitleFromServer + firstWord = value.split("\\s+")[0]; // Miss-TitleFromServer jsonString = jsonString.replace(firstWord, propsMap.getProperty(firstWord)); - firstWord = propsMap.getProperty(firstWord); //MIS + firstWord = propsMap.getProperty(firstWord); // MIS langcode = nameObject.getString("language"); } else { @@ -5282,7 +5293,7 @@ public static String inputTitleHandler(String jsonString) { if (titleObject.getString("code").equals(firstWord)) { String titleName = titleObject.getString("titleName"); jsonString = jsonString.replace(firstWord, titleName); - break; + break; } } } catch (Exception e) { @@ -5292,5 +5303,4 @@ public static String inputTitleHandler(String jsonString) { return jsonString; } - } From 5edc5d016c8512d0a9b5d8c0da45715e04564ad2 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 13 Sep 2023 16:46:00 +0530 Subject: [PATCH 141/204] xml --- automationtests/testNgXmlFiles/masterdataApi.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/testNgXmlFiles/masterdataApi.xml b/automationtests/testNgXmlFiles/masterdataApi.xml index 60c15e078de..761a84e5aa0 100644 --- a/automationtests/testNgXmlFiles/masterdataApi.xml +++ b/automationtests/testNgXmlFiles/masterdataApi.xml @@ -724,7 +724,7 @@ - + From 6e547fb5bc3ce5e4e732f151bc3b38e844a95023 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 13 Sep 2023 17:29:27 +0530 Subject: [PATCH 142/204] MOSIP-29286 --- .../ida/BioAuthHotListLock/BioAuth.hbs | 34 + .../ida/BioAuthHotListLock/BioAuth.yml | 309 ++++ .../ida/BioAuthHotListLock/BioAuthResult.hbs | 9 + .../ida/BioAuthHotListLock/EkycBio.yml | 1345 +++++++++++++++++ .../ida/BioAuthHotListLock/error.hbs | 17 + .../ida/BioAuthHotListLock/errorKyc.hbs | 9 + .../ida/BlockHotlistAPI/BlockHotlistAPI.yml | 15 + .../UnBlockHotlistAPI/UnBlockHotlistAPI.yml | 15 + .../testNgXmlFiles/authenticationApi.xml | 4 +- 9 files changed, 1755 insertions(+), 2 deletions(-) create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.hbs create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.yml create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthResult.hbs create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/error.hbs create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/errorKyc.hbs diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.hbs b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.hbs new file mode 100644 index 00000000000..ac818dc8d78 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.hbs @@ -0,0 +1,34 @@ +{ + "biometrics": [ + { + "data": { + "bioSubType": "{{bioSubType}}", + "bioType": "{{bioType}}", + "bioValue": "{{bioValue}}" , + "deviceCode": "{{deviceCode}}", + "deviceProviderID": "{{deviceProviderID}}", + "deviceServiceID": "{{deviceServiceID}}", + "deviceServiceVersion": "{{deviceServiceVersion}}", + "env": "Staging", + "domainUri": "https://qa-triple.mosip.net", + "digitalId": { + "serialNo": "{{serialNo}}", + "make": "{{make}}", + "model": "{{model}}", + "type": "{{type}}", + "deviceSubType": "{{deviceSubType}}", + "deviceProvider": "{{deviceProvider}}", + "deviceProviderId": "{{deviceProviderId}}", + "dateTime": "{{dateTime}}" + }, + "mosipProcess": "Auth", + "purpose": "Auth", + "qualityScore": 70, + "requestedScore": 70, + "timestamp": "{{timestamp}}", + "transactionId": "{{transactionId}}" + } + } + ], + "timestamp": "{{timestamp}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.yml b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.yml new file mode 100644 index 00000000000..e131ba0d647 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuth.yml @@ -0,0 +1,309 @@ +BioAuth: + auth_BioAuth_Biometric_Face_With_blocked_UIN_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_Positive_unblockUIN_valid_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_Face_With_Locked_UIN_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_Positive_LockUIN_valid_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_Face_With_blocked_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_Face_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_RingFinger_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_LeftIndexFingerr_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_IRIS_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/error + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_EkycBio_Face_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/errorKyc + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_RingFinger_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/errorKyc + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_LeftMiddleFingerr_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/errorKyc + input: '{ + "bioSubType": "Left MiddleFinger", + "bioType": "Finger", + "bioValue": "$LEFTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_RIGHTIRIS_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/errorKyc + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthResult.hbs b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthResult.hbs new file mode 100644 index 00000000000..1c86da21a83 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthResult.hbs @@ -0,0 +1,9 @@ +{ + "authResponse": { + "body": { + "response": { + "authStatus": "{{authStatus}}" + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml b/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml new file mode 100644 index 00000000000..0da7268b342 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml @@ -0,0 +1,1345 @@ +EkycBio: + auth_EkycBio_Face_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_Face_With_Valid_Infant_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_Infant_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_Face_With_draft_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GetDraft_all_valid_smoke_sid_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RingFinger_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftMiddleFingerr_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left MiddleFinger", + "bioType": "Finger", + "bioValue": "$LEFTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftIndexFingerr_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftLittleFinger_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left LittleFinger", + "bioType": "Finger", + "bioValue": "$LEFTLITTLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightIndexFinger_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right IndexFinger", + "bioType": "Finger", + "bioValue": "$RIGHTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightRingFinger_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right RingFinger", + "bioType": "Finger", + "bioValue": "$RIGHTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightMiddleFinger_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right MiddleFinger", + "bioType": "Finger", + "bioValue": "$RIGHTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightLittleFinger_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right LittleFinger", + "bioType": "Finger", + "bioValue": "$RIGHTLITTLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftThumb_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left Thumb", + "bioType": "Finger", + "bioValue": "$LEFTTHUMB$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightThumb_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right Thumb", + "bioType": "Finger", + "bioValue": "$RIGHTTHUMB$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightIris_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftIris_With_Valid_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left", + "bioType": "Iris", + "bioValue": "$LEFTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_Face_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RingFinger_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftMiddleFingerr_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left MiddleFinger", + "bioType": "Finger", + "bioValue": "$LEFTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftIndexFingerr_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftLittleFinger_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left LittleFinger", + "bioType": "Finger", + "bioValue": "$LEFTLITTLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightIndexFinger_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right IndexFinger", + "bioType": "Finger", + "bioValue": "$RIGHTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightRingFinger_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right RingFinger", + "bioType": "Finger", + "bioValue": "$RIGHTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightMiddleFinger_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right MiddleFinger", + "bioType": "Finger", + "bioValue": "$RIGHTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightLittleFinger_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right LittleFinger", + "bioType": "Finger", + "bioValue": "$RIGHTLITTLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftThumb_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left Thumb", + "bioType": "Finger", + "bioValue": "$LEFTTHUMB$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightThumb_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right Thumb", + "bioType": "Finger", + "bioValue": "$RIGHTTHUMB$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RightIris_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_LeftIris_With_Valid_VID_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left", + "bioType": "Iris", + "bioValue": "$LEFTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_inValid_transactionID_uin_Neg: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123HGFRFDDR3245@@456&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "123HGFRFDDR3245@@456", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_inValid_transactionID_vid_Neg: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123HGFRFDDR3245@@456&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "123HGFRFDDR3245@@456", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_blank_transactionID_uin_Neg: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_blank_transactionID_vid_Neg: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_with_revoked_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_to_revoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_invalid_uin_bioSubType: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "L@@@$%4556eft", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_invalid_bioSubType_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "L@@@$%4556eft", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_blank_uin_bioSubType: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_blank_bioSubType_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Blank_uin_bioType: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Blank_bioType_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Invalid_uin_bioType: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "ddff3355", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Invalid_bioType_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "ddff3355", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Iris_With_FaceBio_uin_Invalid: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left", + "bioType": "Iris", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Iris_With_FaceBio_Invalid_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left", + "bioType": "Iris", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Finger_With_FaceBio_uin_Invalid: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Finger_With_FaceBio_Invalid_VID: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Finger_With_dummy_partnerkey_Pos_vid: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_Face_With_Deactivated_uin: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$id=$ID:AddIdentity_deactivate_UIN_smoke_sid_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/EkycBioResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_Face_With_Valid_uin_NOAUTH_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/EkycBio/EkycBio + outputTemplate: ida/EkycBio/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/error.hbs b/automationtests/src/main/resources/ida/BioAuthHotListLock/error.hbs new file mode 100644 index 00000000000..3ae04f7cbac --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/error.hbs @@ -0,0 +1,17 @@ +{ + "authResponse": { + "body": { + "errors": [ + {{#each errors}} + { + "errorCode": "{{errorCode}}" + } + {{#unless @last}},{{/unless}} + {{/each}} + ], + "response": { + "authStatus": {{authStatus}} + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/errorKyc.hbs b/automationtests/src/main/resources/ida/BioAuthHotListLock/errorKyc.hbs new file mode 100644 index 00000000000..9d51fe4b7fb --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/errorKyc.hbs @@ -0,0 +1,9 @@ +{ + "authResponse": { + "body": { + "response": { + "kycStatus": {{kycStatus}} + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml b/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml index 5b925292c97..269fac266bc 100644 --- a/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml +++ b/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml @@ -130,6 +130,21 @@ HotlistAPI: "idType": "DEVICE", "requestTime": "$TIMESTAMP$", "expiryTimestamp": "" + }' + output: '{ + "status": "BLOCKED" + }' + auth_BlockHotlistAPI_All_Valid_Smoke_deviceProviderId: + endPoint: /v1/hotlist/block + role: hotlist + restMethod: post + inputTemplate: ida/BlockHotlistAPI/blockHotlistAPI + outputTemplate: ida/BlockHotlistAPI/blockHotlistAPIResult + input: '{ + "id": "571203", + "idType": "DEVICE", + "requestTime": "$TIMESTAMP$", + "expiryTimestamp": "" }' output: '{ "status": "BLOCKED" diff --git a/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPI.yml b/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPI.yml index c29eaca1058..f82dfdf9d8b 100644 --- a/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPI.yml +++ b/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPI.yml @@ -85,6 +85,21 @@ HotlistAPI: "idType": "DEVICE", "requestTime": "$TIMESTAMP$", "expiryTimestamp": "120" + }' + output: '{ + "status": "UNBLOCKED" + }' + auth_HotlistAPI_All_Valid_Smoke_deviceProviderId: + endPoint: /v1/hotlist/unblock + role: hotlist + restMethod: post + inputTemplate: ida/UnBlockHotlistAPI/UnblockHotlistAPI + outputTemplate: ida/UnBlockHotlistAPI/UnblockHotlistAPIResult + input: '{ + "id": "571203", + "idType": "DEVICE", + "requestTime": "$TIMESTAMP$", + "expiryTimestamp": "120" }' output: '{ "status": "UNBLOCKED" diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index 9127ad26f94..8d3a321f28a 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -172,7 +172,7 @@ - + @@ -180,7 +180,7 @@ - + From b8c1e409301e202dbe98f3ad0ced3ee0ca8ce0d0 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 13 Sep 2023 21:48:54 +0530 Subject: [PATCH 143/204] MOSIP-29380 --- .../apirig/admin/fw/util/AdminTestUtil.java | 12 + .../resources/config/application.properties | 3 + .../AuthenticateUserVCI.yml | 231 ++++++++++++++ .../AuthorizationCodeVCI.yml | 112 +++++++ .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 148 ++++++++- .../VCI/GetCredential/GetCredential.yml | 297 +++++++++++++++++- .../GetCredentialEmptyCredDef.hbs | 10 + .../GetCredential/GetCredentialNoCredDef.hbs | 10 + .../OAuthDetailsRequestVCI.yml | 216 ++++++++++++- 9 files changed, 1015 insertions(+), 24 deletions(-) create mode 100644 automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialEmptyCredDef.hbs create mode 100644 automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoCredDef.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index fc7ddf999ea..1763cfe71e4 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3169,6 +3169,18 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$UINCODEVERIFIERPOS1$", UIN_CODE_VERIFIER_POS_1); } + if (jsonString.contains("$CODECHALLENGE$")) { + jsonString = replaceKeywordWithValue(jsonString, "$CODECHALLENGE$", properties.getProperty("codeChallenge")); + } + + if (jsonString.contains("$CODEVERIFIER$")) { + jsonString = replaceKeywordWithValue(jsonString, "$CODEVERIFIER$", properties.getProperty("codeVerifier")); + } + + if (jsonString.contains("$VCICONTEXTURL$")) { + jsonString = replaceKeywordWithValue(jsonString, "$VCICONTEXTURL$", properties.getProperty("vciContextURL")); + } + if (jsonString.contains("$PROOFJWT$")) { String oidcJWKKeyString = getJWKKey(oidcJWK1); diff --git a/automationtests/src/main/resources/config/application.properties b/automationtests/src/main/resources/config/application.properties index 9ae511c5394..2ddf6d7adfd 100644 --- a/automationtests/src/main/resources/config/application.properties +++ b/automationtests/src/main/resources/config/application.properties @@ -59,6 +59,9 @@ publishPolicyurl=/v1/policymanager/policies/POLICYID/group/POLICYGROUPID/publish clearCertificateURL=v1/identity/clearKeys?moduleName=$MODULENAME$&certsDir=$CERTSDIR$ picturevalue=iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAABCSURBVChTbYtBEgAgCAL7/6eNhBy09qDi6gpjXZSxUU8o/jrfpDmcmY1QAOWhgTswv6sSm8zVhULlgst++8T51IjYNUHdI+4XZHoAAAAASUVORK5CYII= XSRFTOKEN=7d01b2a8-b89d-41ad-9361-d7f6294021d1 +vciContextURL=https://www.w3.org/2018/credentials/v1 +codeChallenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM +codeVerifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk adminAutoGeneratedIdPropFileName=/admin/autoGeneratedId.properties masterDataAutoGeneratedIdPropFileName=/masterdata/autoGeneratedId.properties diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index d942d933545..981fa953945 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -360,4 +360,235 @@ AuthenticateUserVCI: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen4_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen5_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen6_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen7_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen8_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen9_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 6f66ef2315f..d44d6309475 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -197,4 +197,116 @@ AuthorizationCodeVCI: "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$" }' output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen5_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen6_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen7_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen8_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen9_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$" +}' + output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index d7418969d17..bdfbebc2546 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -13,7 +13,7 @@ GenerateTokenVCI: "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", "client_assertion": "$CLIENT_ASSERTION_JWK$", "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" + "code_verifier": "$CODEVERIFIER$" }' output: '{ "token_type": "Bearer" @@ -93,7 +93,7 @@ GenerateTokenVCI: "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", "client_assertion": "$CLIENT_ASSERTION_JWK$", "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" + "code_verifier": "$CODEVERIFIER$" }' output: '{ "error": "pkce_failed" @@ -113,7 +113,7 @@ GenerateTokenVCI: "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", "client_assertion": "$CLIENT_ASSERTION_JWK$", "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" + "code_verifier": "$CODEVERIFIER$" }' output: '{ "token_type": "Bearer" @@ -133,7 +133,147 @@ GenerateTokenVCI: "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", "client_assertion": "$CLIENT_ASSERTION_JWK$", "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen3_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen3_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen4_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen4_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen5_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen5_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen6_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen6_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen7_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen7_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen8_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen8_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen9_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen9_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" }' output: '{ "token_type": "Bearer" diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index 81c3dbddd6e..3679247b3e8 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -12,7 +12,7 @@ GetCredential: "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "https://www.w3.org/2018/credentials/v1"}], + "@context": [{context: "$VCICONTEXTURL$"}], "proof_type": "jwt", "proof_jwt": "$PROOFJWT$" }' @@ -32,7 +32,7 @@ GetCredential: "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen1_Smoke_sid_access_token$", "format": "dfsfd", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "https://www.w3.org/2018/credentials/v1"}], + "@context": [{context: "$VCICONTEXTURL$"}], "proof_type": "jwt", "proof_jwt": "$PROOFJWT$" }' @@ -53,10 +53,301 @@ GetCredential: "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen2_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "https://www.w3.org/2018/credentials/v1"}], + "@context": [{context: "$VCICONTEXTURL$"}], "proof_type": "jwt", "proof_jwt": "wewrt" }' output: '{ "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen3_Smoke_sid_access_token$", + "format": "$REMOVE$", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_vc_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen4_Smoke_sid_access_token$", + "format": " ", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_vc_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen5_Smoke_sid_access_token$", + "format": "", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_vc_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval1_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen6_Smoke_sid_access_token$", + "format": "jwt_vc_json", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unknown_error" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval2_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen7_Smoke_sid_access_token$", + "format": "jwt_vc_json-ld", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unknown_error" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval3_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen8_Smoke_sid_access_token$", + "format": "ldp_vc, jwt_vc_json-ld", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredentialNoCredDef + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "credential_definition" : "$REMOVE$", + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredentialEmptyCredDef + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Cred_Def_Value_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: ""}, {types: ""}], + "@context": [{context: ""}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: " "}, {types: " "}], + "@context": [{context: " "}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Mandate_Val1_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Mandate_Val2_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Context_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: ""}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval_Val_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "sfsdf"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_type" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialEmptyCredDef.hbs b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialEmptyCredDef.hbs new file mode 100644 index 00000000000..5d7d77356e9 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialEmptyCredDef.hbs @@ -0,0 +1,10 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : {}, + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoCredDef.hbs b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoCredDef.hbs new file mode 100644 index 00000000000..66fef780c5d --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoCredDef.hbs @@ -0,0 +1,10 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : "{{credential_definition}}", + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index de9a42fb3e3..ea3ad4652f9 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -18,7 +18,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -44,7 +44,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -74,7 +74,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -100,7 +100,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -130,7 +130,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "sdgfdg" }' output: '{ @@ -190,7 +190,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "" }' output: '{ @@ -272,7 +272,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "$REMOVE$" }' output: '{ @@ -324,7 +324,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -350,7 +350,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -376,7 +376,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -402,7 +402,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -428,7 +428,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -454,7 +454,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -506,7 +506,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -536,7 +536,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -566,7 +566,7 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ @@ -592,7 +592,189 @@ OAuthDetailsRequestVCI: "nonce": "973eieljzng", "state": "eree2311", "claimsLocales": "en", - "codeChallenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", "codeChallengeMethod": "S256" }' output: '{ From ff1b8f3de23d540bbb757e1f26ac66b39037a926 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Thu, 14 Sep 2023 09:54:05 +0530 Subject: [PATCH 144/204] resolve issue --- .../BiometricAttributes.yml | 3 +++ .../DecommissionRegCenter.yml | 1 + .../DeleteTemplate/DeleteTemplate.yml | 1 + .../DeleteTemplate/deleteTemplateResult.hbs | 3 --- .../DeleteUserCenterMapping.yml | 2 +- .../deleteUserCenterMappingResult.hbs | 3 --- .../DeleteZoneUser/DeleteZoneUser.yml | 4 ++-- .../DeleteZoneUser/deleteZoneUserResult.hbs | 3 --- .../DeviceType/CreateDeviceType.yml | 20 +++++++++++++++++++ .../FetchAllIdschema/FetchAllIdschema.yml | 1 + .../FetchAllLocation/FetchAllLocation.yml | 5 ++--- .../FetchAllTemplates/FetchAllTemplates.yml | 2 +- .../FetchAllUISpec/FetchAllUISpec.yml | 1 + .../FetchAllUserDetails.yml | 1 + .../FetchAllValidDocuments.yml | 1 + .../FetchAppConfig/FetchAppConfig.yml | 1 + .../FetchAppConfig/fetchAppConfigResult.hbs | 4 +--- .../FetchDistinctDynamicField.yml | 2 +- .../FetchDistinctDynamicFieldByLangcode.yml | 1 + .../FetchDynamicField/FetchDynamicField.yml | 2 +- .../masterdata/FetchHolidays/FetchHoliday.yml | 7 +++++-- .../FetchIdSchema/FetchIdSchema.yml | 1 + .../FetchLocation/FetchLocation.yml | 5 +++++ .../FetchMissingDynamicField.yml | 2 ++ .../FetchMissingLocation.yml | 1 + .../FetchMissingTemplates.yml | 2 ++ .../masterdata/FetchRegCent/FetchRegCent.yml | 1 + .../FetchTemplate/FetchTemplate.yml | 3 +++ .../FetchTemplateType/FetchTemplateType.yml | 2 ++ .../fetchTemplateTypeResult.hbs | 10 ---------- .../masterdata/FetchUISpec/FetchUISpec.yml | 1 + .../FetchValidDocuments.yml | 1 + .../FetchValidDocumentsByDocCategoryCode.yml | 1 + .../FetchWorkingDays/FetchWorkingDays.yml | 3 ++- .../FilterLocationData/FilterLocationData.yml | 4 ++-- .../FilterTemplateDetails.yml | 3 +++ .../GetBiometricTypes/GetBiometricTypes.yml | 2 +- .../GetBiometricTypesByLangcode.yml | 1 + .../GetDocCategory/GetDocCategory.yml | 1 + .../GetDocCategoryByLangCode.yml | 1 + .../GetDocumentTypeByLangCode.yml | 1 + .../GetExceptionalHolidays.yml | 1 + .../GetHolidaysMissingIds.yml | 1 + .../GetIdTypeByLangCode.yml | 1 + .../masterdata/GetLanguage/GetLanguage.yml | 3 ++- ...ocationHierarchyLevelByLastUpdatedDate.yml | 1 + .../masterdata/GetLocations/GetLocations.yml | 1 + .../masterdata/GetMachines/GetMachines.yml | 1 + .../GetMappedMachinesByRegCentID.yml | 1 + .../GetMissingDocumentCategoryByLangcode.yml | 1 + .../GetMissingDocumentTypeByLangcode.yml | 3 ++- .../GetPacketRejectionReason.yml | 1 + .../GetPossiableValues/GetPossiableValues.yml | 3 +++ .../GetUserDetails/GetUserDetails.yml | 2 -- .../getUserDetailsByIDResult.hbs | 1 - .../masterdata/Holiday/UpdateHoliday.yml | 2 +- .../CreateRegistrationCenter.yml | 8 ++++---- .../UpdateRegistrationCenter.yml | 9 +++++---- .../SearchDynamicField/SearchDynamicField.yml | 2 ++ .../SearchMachine/SearchMachine.yml | 8 ++++---- .../SearchTemplateDetails.yml | 5 +++++ .../masterdata/Template/CreateTemplate.yml | 3 ++- .../UpdateDeviceTypeStatus.yml | 19 ++++++++++++++++++ .../UpdateHolidayStatus.yml | 15 ++++++++++++++ .../UpdateUserCenterMapping.yml | 1 - .../UserCenterMapping/UserCenterMapping.yml | 1 - .../updateUserCenterMapping.hbs | 1 - .../userCenterMappingResult.hbs | 1 - .../ValidDocumentSearch.yml | 4 ++-- .../masterdata/ZoneUser/CreateZoneUser.yml | 4 ++-- .../masterdata/ZoneUser/UpdateZoneUser.yml | 4 ++-- .../masterdata/ZoneUser/zoneUserResult.hbs | 4 ---- 72 files changed, 156 insertions(+), 70 deletions(-) diff --git a/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml b/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml index 86f70e4fb97..aaf941a200d 100644 --- a/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml +++ b/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml @@ -2,6 +2,7 @@ BiometricAttributes: MasterData_BiometricAttributes_All_Valid_Smoke_sid: endPoint: /v1/masterdata/biometricattributes role: admin + checkErrorsOnlyInResponse: true templateFields: ["langCode"] restMethod: post inputTemplate: masterdata/BiometricAttributes/biometricAttributes @@ -16,6 +17,8 @@ BiometricAttributes: "requesttime": "$TIMESTAMP$" }' output: '{ + "code": "TST", + "langCode": "eng" }' MasterData_BiometricAttributes_Invalid_empty_biometricTypeCode: diff --git a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml index 78d2aae5906..bcc01034306 100644 --- a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml +++ b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/DecommissionRegCenter.yml @@ -2,6 +2,7 @@ DecommissionRegCenter: MasterData_DecommissionRegCenter_All_Valid_Smoke_sid: endPoint: /v1/masterdata/registrationcenters/decommission/{regCenterID} role: globalAdmin + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: masterdata/DecommissionRegCenter/decommissionRegCenter outputTemplate: masterdata/DecommissionRegCenter/decommissionRegCenterResult diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml b/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml index 6a32864431b..719d0a9ca13 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml +++ b/automationtests/src/main/resources/masterdata/DeleteTemplate/DeleteTemplate.yml @@ -2,6 +2,7 @@ DeleteTemplate: MasterData_DeleteTemplate_All_Valid_Smoke_sid: endPoint: /v1/masterdata/templates/{id} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: delete inputTemplate: masterdata/DeleteTemplate/deleteTemplate diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs b/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs index 3d6bd8ac86b..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "id": "{{id}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/DeleteUserCenterMapping.yml b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/DeleteUserCenterMapping.yml index fa1a3e76f60..57696d475da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/DeleteUserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/DeleteUserCenterMapping.yml @@ -2,6 +2,7 @@ DeleteUserCenterMapping: MasterData_DeleteUserCenterMapping_All_Valid_Smoke: endPoint: /v1/masterdata/usercentermapping/{id} role: admin + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: masterdata/DeleteUserCenterMapping/deleteUserCenterMapping outputTemplate: masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult @@ -9,7 +10,6 @@ DeleteUserCenterMapping: "id": "func_auto_test_user" }' output: '{ - "id": "func_auto_test_user" }' MasterData_DeleteUserCenterMapping_in_Valid: endPoint: /v1/masterdata/usercentermapping/{id} diff --git a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs index 7809fdbd739..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs @@ -1,5 +1,2 @@ { -"response":{ -"id":"{{id}}" -} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteZoneUser/DeleteZoneUser.yml b/automationtests/src/main/resources/masterdata/DeleteZoneUser/DeleteZoneUser.yml index e09619a6a1b..a691d8cca0c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteZoneUser/DeleteZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/DeleteZoneUser/DeleteZoneUser.yml @@ -2,13 +2,13 @@ DeleteZoneUser: MasterData_DeleteZoneUser_All_Valid_Smoke_sid: endPoint: /v1/masterdata/zoneuser/{userid}/{zonecode} role: admin + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: masterdata/DeleteZoneUser/deleteZoneUser outputTemplate: masterdata/DeleteZoneUser/deleteZoneUserResult input: '{ "userid": "func_auto_test_user", - "zonecode": "BSN" + "zonecode": "$ZONE_CODE$" }' output: '{ - "id": "func_auto_test_user" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs b/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs index 7809fdbd739..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs @@ -1,5 +1,2 @@ { -"response":{ -"id":"{{id}}" -} } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml index 68749a5e1c6..73ddbb3b08a 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml +++ b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml @@ -18,6 +18,26 @@ CreateDeviceType: "code": "GST3", "langCode": "eng" }' + + MasterData_CreateDeviceType_TO_verify_Deactivation: + endPoint: /v1/masterdata/devicetypes + role: admin + templateFields: ["description"] + restMethod: post + inputTemplate: masterdata/DeviceType/deviceType + outputTemplate: masterdata/DeviceType/deviceTypeResult + input: '{ + "code": "REG", + "description": "test 1.0.8", + "isActive": true, + "langCode": "eng", + "name": "REG", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "code": "ABC3", + "langCode": "eng" +}' MasterData_CreateDeviceType_All_Valid_Mandatory_Fields: endPoint: /v1/masterdata/devicetypes role: admin diff --git a/automationtests/src/main/resources/masterdata/FetchAllIdschema/FetchAllIdschema.yml b/automationtests/src/main/resources/masterdata/FetchAllIdschema/FetchAllIdschema.yml index 1da2bba0e32..6c7fd4c8e45 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllIdschema/FetchAllIdschema.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllIdschema/FetchAllIdschema.yml @@ -2,6 +2,7 @@ FetchAllIdschema: MasterData_FetchAllIdschema_valid_smoke: endPoint: /v1/masterdata/idschema/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllIdschema/fetchAllIdschema outputTemplate: masterdata/FetchAllIdschema/fetchAllIdschemaResult diff --git a/automationtests/src/main/resources/masterdata/FetchAllLocation/FetchAllLocation.yml b/automationtests/src/main/resources/masterdata/FetchAllLocation/FetchAllLocation.yml index c2a93f362bc..c15f8db8205 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllLocation/FetchAllLocation.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllLocation/FetchAllLocation.yml @@ -2,6 +2,7 @@ FetchAllLocation: MasterData_FetchAllLocation_valid_smoke: endPoint: /v1/masterdata/locations/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllLocation/fetchAllLocation outputTemplate: masterdata/FetchAllLocation/fetchAllLocationResult @@ -9,7 +10,5 @@ FetchAllLocation: }' output: '{ -"data": [{ - - }] + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllTemplates/FetchAllTemplates.yml b/automationtests/src/main/resources/masterdata/FetchAllTemplates/FetchAllTemplates.yml index 14eb0e8b9a7..76237bcfd09 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllTemplates/FetchAllTemplates.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllTemplates/FetchAllTemplates.yml @@ -2,6 +2,7 @@ FetchAllTemplates: MasterData_FetchAllTemplates_AllValid_smoke: endPoint: /v1/masterdata/templates/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllTemplates/fetchAllTemplates outputTemplate: masterdata/FetchAllTemplates/fetchAllTemplatesResult @@ -9,5 +10,4 @@ FetchAllTemplates: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml b/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml index 0978bfe8f4f..568f16f14a3 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllUISpec/FetchAllUISpec.yml @@ -2,6 +2,7 @@ FetchAllUISpec: MasterData_FetchAllUISpec_valid_smoke: endPoint: /v1/masterdata/uispec/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllUISpec/fetchAllUISpec outputTemplate: masterdata/FetchAllUISpec/fetchAllUISpecResult diff --git a/automationtests/src/main/resources/masterdata/FetchAllUserDetails/FetchAllUserDetails.yml b/automationtests/src/main/resources/masterdata/FetchAllUserDetails/FetchAllUserDetails.yml index e603f7a3ec9..aa82c48e514 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllUserDetails/FetchAllUserDetails.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllUserDetails/FetchAllUserDetails.yml @@ -2,6 +2,7 @@ FetchAllUserDetails: MasterData_FetchAllUserDetails_valid_smoke: endPoint: /v1/masterdata/usersdetails role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllUserDetails/fetchAllUserDetails outputTemplate: masterdata/FetchAllUserDetails/fetchAllUserDetailsResult diff --git a/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/FetchAllValidDocuments.yml b/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/FetchAllValidDocuments.yml index 4f653ab87e7..7767afae48c 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/FetchAllValidDocuments.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/FetchAllValidDocuments.yml @@ -2,6 +2,7 @@ FetchAllValidDocuments: MasterData_FetchAllValidDocuments_valid_smoke: endPoint: /v1/masterdata/validdocuments/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllValidDocuments/fetchAllValidDocuments outputTemplate: masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult diff --git a/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml b/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml index 53e4e3f6c29..36266b497ce 100644 --- a/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml +++ b/automationtests/src/main/resources/masterdata/FetchAppConfig/FetchAppConfig.yml @@ -2,6 +2,7 @@ FetchAppConfig: MasterData_FetchAppConfig_allValid_smoke: endPoint: /v1/masterdata/configs role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAppConfig/fetchAppConfig outputTemplate: masterdata/FetchAppConfig/fetchAppConfigResult diff --git a/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs b/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs index 48181c1b195..c1860fa3b57 100644 --- a/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAppConfig/fetchAppConfigResult.hbs @@ -1,5 +1,3 @@ { - "response": { - "mandatoryLanguages": "{{mandatoryLanguages}}" - } + } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/FetchDistinctDynamicField.yml b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/FetchDistinctDynamicField.yml index f550ba671e3..84f461e5c5b 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/FetchDistinctDynamicField.yml +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/FetchDistinctDynamicField.yml @@ -2,6 +2,7 @@ FetchDistinctDynamicField: Masterdata_FetchDistinctDynamicField_AllValid_smoke: endPoint: /v1/masterdata/dynamicfields/distinct role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchDistinctDynamicField/fetchDistinctDynamicField outputTemplate: masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult @@ -9,5 +10,4 @@ FetchDistinctDynamicField: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml index 67eeeb401bf..5b110e6d258 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml @@ -2,6 +2,7 @@ FetchDistinctDynamicFieldByLangcode: Masterdata_FetchDistinctDynamicFieldByLangcode_AllValid_smoke: endPoint: /v1/masterdata/dynamicfields/distinct/{langCode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcode outputTemplate: masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult diff --git a/automationtests/src/main/resources/masterdata/FetchDynamicField/FetchDynamicField.yml b/automationtests/src/main/resources/masterdata/FetchDynamicField/FetchDynamicField.yml index 899efabf2ef..f2880f3993e 100644 --- a/automationtests/src/main/resources/masterdata/FetchDynamicField/FetchDynamicField.yml +++ b/automationtests/src/main/resources/masterdata/FetchDynamicField/FetchDynamicField.yml @@ -2,6 +2,7 @@ FetchDynamicField: Masterdata_FetchDynamicField_AllValid_smoke: endPoint: /v1/masterdata/dynamicfields role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchDynamicField/fetchDynamicField outputTemplate: masterdata/FetchDynamicField/fetchDynamicFieldResult @@ -9,5 +10,4 @@ FetchDynamicField: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml b/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml index f4a864bb571..17c9f887594 100644 --- a/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml +++ b/automationtests/src/main/resources/masterdata/FetchHolidays/FetchHoliday.yml @@ -2,6 +2,7 @@ FetchHolidays: MasterData_FetchHolidays_allValid_smoke_get: endPoint: /v1/masterdata/holidays role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchHolidays/fetchHoliday outputTemplate: masterdata/FetchHolidays/fetchHolidayResult @@ -12,9 +13,10 @@ FetchHolidays: output: '{ }' - MasterData_FetchHolidays_allValid_smoke_with Id: + MasterData_FetchHolidays_allValid_smoke_with_Id: endPoint: /v1/masterdata/holidays/{holidayid} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchHolidays/fetchHoliday outputTemplate: masterdata/FetchHolidays/fetchHolidayResult @@ -24,9 +26,10 @@ FetchHolidays: }' output: '{ }' - MasterData_FetchHolidays_allValid_smoke_with Id and langCode: + MasterData_FetchHolidays_allValid_smoke_with_Id_and_langCode: endPoint: /v1/masterdata/holidays/{holidayid}/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchHolidays/fetchHoliday outputTemplate: masterdata/FetchHolidays/fetchHolidayResult diff --git a/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml b/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml index e06ac1c4508..3f97f9f9b7a 100644 --- a/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml +++ b/automationtests/src/main/resources/masterdata/FetchIdSchema/FetchIdSchema.yml @@ -2,6 +2,7 @@ FetchIdSchema: MasterData_FetchIdSchema_allValid_smoke_with_lang: endPoint: /v1/masterdata/idschema/latest role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchIdSchema/fetchIdSchema outputTemplate: masterdata/FetchIdSchema/fetchIdSchemaResult diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml b/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml index 4165a65c0ab..c0b11186dda 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml +++ b/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml @@ -2,6 +2,7 @@ FetchLocation: MasterData_FetchLocation_langcode_smoke: endPoint: /v1/masterdata/locations/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchLocation/fetchLocation outputTemplate: masterdata/FetchLocation/fetchLocationResult @@ -39,6 +40,7 @@ FetchLocation: MasterData_FetchLocation_langcode_locationcode_smoke: endPoint: /v1/masterdata/locations/{locationcode}/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchLocation/fetchLocation outputTemplate: masterdata/FetchLocation/fetchLocationResult @@ -96,6 +98,7 @@ FetchLocation: MasterData_FetchLocation_details_by_Langcode_smoke: endPoint: /v1/masterdata/locations/info/{locationcode}/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchLocation/fetchLocation outputTemplate: masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult @@ -151,6 +154,7 @@ FetchLocation: MasterData_FetchLocation_details_Langcode_smoke: endPoint: /v1/masterdata/locations/level/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchLocation/fetchLocation outputTemplate: masterdata/FetchLocation/fetchLocationResult @@ -166,6 +170,7 @@ FetchLocation: MasterData_FetchLocation_details_hierarchyname_smoke: endPoint: /v1/masterdata/locations/locationhierarchy/{hierarchyname} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchLocation/fetchLocation outputTemplate: masterdata/FetchLocation/fetchLocationResult diff --git a/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml b/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml index 900aea9168d..9f79b88a71b 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingDynamicField/FetchMissingDynamicField.yml @@ -2,6 +2,7 @@ FetchMissingDynamicField: MasterData_FetchMissingDynamicField_valid_smoke: endPoint: /v1/masterdata/dynamicfields/missingids/{langcode}?fieldName={fieldName} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchMissingDynamicField/fetchMissingDynamicField @@ -15,6 +16,7 @@ FetchMissingDynamicField: MasterData_FetchMissingDynamicField_Allvalid_smoke: endPoint: /v1/masterdata/dynamicfields/missingids/{langcode}?fieldName={fieldName} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchMissingDynamicField/fetchMissingDynamicField diff --git a/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml b/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml index 14d55907500..0986d88a8b5 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingLocation/FetchMissingLocation.yml @@ -2,6 +2,7 @@ FetchMissingLocation: MasterData_FetchMissingLocation_valid_smoke: endPoint: /v1/masterdata/locations/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchMissingLocation/fetchMissingLocation outputTemplate: masterdata/FetchMissingLocation/fetchMissingLocationResult diff --git a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml index 56e3db5e5fc..7bca70f7cd4 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/FetchMissingTemplates.yml @@ -2,6 +2,7 @@ FetchMissingTemplates: MasterData_FetchMissingTemplates_valid_smoke: endPoint: /v1/masterdata/templates/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchMissingTemplates/fetchMissingTemplates @@ -15,6 +16,7 @@ FetchMissingTemplates: MasterData_FetchMissingTemplates_Allvalid_smoke: endPoint: /v1/masterdata/templates/missingids/{langcode}?fieldName={fieldName} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchMissingTemplates/fetchMissingTemplates diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml index 8a91f5bf56b..22a513c93ae 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml @@ -160,6 +160,7 @@ FetchRegCent: MasterData_FetchRegCent_Holidays_allValid_smoke: endPoint: /v1/masterdata/getregistrationcenterholidays/{langcode}/{registrationcenterid}/{year} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent diff --git a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml index bbbb83ce036..0686db60f05 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml +++ b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml @@ -2,6 +2,7 @@ FetchTemplate: MasterData_FetchTemplate_allValid_smoke_Get: endPoint: /v1/masterdata/templates role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchTemplate/fetchTemplate outputTemplate: masterdata/FetchTemplate/fetchTemplateResult @@ -15,6 +16,7 @@ FetchTemplate: MasterData_FetchTemplate_allValid_ByLangcode_smoke: endPoint: /v1/masterdata/templates/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchTemplate/fetchTemplate outputTemplate: masterdata/FetchTemplate/fetchTemplateResult @@ -39,6 +41,7 @@ FetchTemplate: }' output: '{ "templates": [{ + "langCode": "eng", "isActive": true }] }' diff --git a/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml b/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml index d3485a8e1f1..e5a908a7707 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml +++ b/automationtests/src/main/resources/masterdata/FetchTemplateType/FetchTemplateType.yml @@ -2,6 +2,7 @@ FetchTemplateType: MasterData_FetchTemplateType_allValid_smoke: endPoint: /v1/masterdata/templatetypes/{code}/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchTemplateType/fetchTemplateType @@ -34,6 +35,7 @@ FetchTemplateType: MasterData_FetchTemplateType_allValid_smoke_langcode: endPoint: /v1/masterdata/templatetypes/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchTemplateType/fetchTemplateType diff --git a/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs index 1a8542e8861..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs @@ -1,12 +1,2 @@ { - "response": { - "templateTypes": [ - {{#each templateTypes}} - { - "isActive": "{{isActive}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml b/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml index e0f4c5b8fb6..fc6fd26d38d 100644 --- a/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchUISpec/FetchUISpec.yml @@ -2,6 +2,7 @@ FetchUISpec: MasterData_FetchUISpec_allValid_smoke_with_lang: endPoint: /v1/masterdata/uispec/{domain}/latest role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchUISpec/fetchUISpec outputTemplate: masterdata/FetchUISpec/fetchUISpecResult diff --git a/automationtests/src/main/resources/masterdata/FetchValidDocuments/FetchValidDocuments.yml b/automationtests/src/main/resources/masterdata/FetchValidDocuments/FetchValidDocuments.yml index 3b2e3c8bd5e..8504ca7526d 100644 --- a/automationtests/src/main/resources/masterdata/FetchValidDocuments/FetchValidDocuments.yml +++ b/automationtests/src/main/resources/masterdata/FetchValidDocuments/FetchValidDocuments.yml @@ -2,6 +2,7 @@ FetchValidDocuments: MasterData_FetchValidDocuments_allValid_smoke_with_lang: endPoint: /v1/masterdata/validdocuments/{languagecode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["languagecode"] restMethod: get inputTemplate: masterdata/FetchValidDocuments/fetchValidDocuments diff --git a/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/FetchValidDocumentsByDocCategoryCode.yml b/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/FetchValidDocumentsByDocCategoryCode.yml index bd0e3fdecd9..203a535d52b 100644 --- a/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/FetchValidDocumentsByDocCategoryCode.yml +++ b/automationtests/src/main/resources/masterdata/FetchValidDocumentsByDocCategoryCode/FetchValidDocumentsByDocCategoryCode.yml @@ -20,6 +20,7 @@ FetchValidDocumentsByDocCategoryCode: MasterData_FetchValidDocumentsByDocCategoryCode_inValid_DocCategory: endPoint: /v1/masterdata/validdocuments/{doccategorycode}/{languagecode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchValidDocumentsByDocCategoryCode/fetchValidDocumentsByDocCategoryCode outputTemplate: masterdata/FetchValidDocumentsByDocCategoryCode/invalidValidDocumentsByDocCategoryCodeResult diff --git a/automationtests/src/main/resources/masterdata/FetchWorkingDays/FetchWorkingDays.yml b/automationtests/src/main/resources/masterdata/FetchWorkingDays/FetchWorkingDays.yml index ee50b7ff813..1a080fd189d 100644 --- a/automationtests/src/main/resources/masterdata/FetchWorkingDays/FetchWorkingDays.yml +++ b/automationtests/src/main/resources/masterdata/FetchWorkingDays/FetchWorkingDays.yml @@ -2,6 +2,7 @@ FetchWorkingDays: MasterData_FetchWorkingDays_allValid_smoke: endPoint: /v1/masterdata/workingdays/{registrationCenterID}/{langCode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langCode"] restMethod: get inputTemplate: masterdata/FetchWorkingDays/fetchWorkingDays @@ -16,6 +17,7 @@ FetchWorkingDays: MasterData_FetchWorkingDays_ByLangcode_allValid_smoke: endPoint: /v1/masterdata/workingdays/{langCode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langCode"] restMethod: get inputTemplate: masterdata/FetchWorkingDays/fetchWorkingDays @@ -25,7 +27,6 @@ FetchWorkingDays: "registrationCenterID": "$REMOVE$" }' output: '{ - "errors": null }' MasterData_FetchWorkingDays_InvalidValid_langCode: endPoint: /v1/masterdata/workingdays/{registrationCenterID}/{langCode} diff --git a/automationtests/src/main/resources/masterdata/FilterLocationData/FilterLocationData.yml b/automationtests/src/main/resources/masterdata/FilterLocationData/FilterLocationData.yml index e73a1e4a5c7..81429a270de 100644 --- a/automationtests/src/main/resources/masterdata/FilterLocationData/FilterLocationData.yml +++ b/automationtests/src/main/resources/masterdata/FilterLocationData/FilterLocationData.yml @@ -10,7 +10,7 @@ FilterLocationData: "filters": [{ "columnName": "Zone", "type": "unique", - "text": "KTA" + "text": "$ZONE_CODE$" }], "languageCode": "eng", "requesttime": "$TIMESTAMP$" @@ -29,7 +29,7 @@ FilterLocationData: "filters": [{ "columnName": "Zone", "type": "", - "text": "KTA" + "text": "$ZONE_CODE$" }], "languageCode": "eng", "requesttime": "$TIMESTAMP$" diff --git a/automationtests/src/main/resources/masterdata/FilterTemplateDetails/FilterTemplateDetails.yml b/automationtests/src/main/resources/masterdata/FilterTemplateDetails/FilterTemplateDetails.yml index 05f46fae2e8..bed10749489 100644 --- a/automationtests/src/main/resources/masterdata/FilterTemplateDetails/FilterTemplateDetails.yml +++ b/automationtests/src/main/resources/masterdata/FilterTemplateDetails/FilterTemplateDetails.yml @@ -2,6 +2,7 @@ FilterTemplateDetails: MasterData_FilterTemplateDetails_All_Valid_Smoke: endPoint: /v1/masterdata/templates/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterTemplateDetails/filterTemplateDetails @@ -26,6 +27,7 @@ FilterTemplateDetails: MasterData_FilterTemplateDetails_FilterType_all: endPoint: /v1/masterdata/templates/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/FilterTemplateDetails/filterTemplateDetails @@ -74,6 +76,7 @@ FilterTemplateDetails: MasterData_FilterTemplateDetails_invalid_text: endPoint: /v1/masterdata/templates/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: post inputTemplate: masterdata/FilterTemplateDetails/filterTemplateDetails diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypes/GetBiometricTypes.yml b/automationtests/src/main/resources/masterdata/GetBiometricTypes/GetBiometricTypes.yml index f6763954ab4..f0f8e2cfc3e 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypes/GetBiometricTypes.yml +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypes/GetBiometricTypes.yml @@ -2,6 +2,7 @@ GetBiometricTypes: Masterdata_GetBiometricTypes_allValid_smoke: endPoint: /v1/masterdata/biometrictypes role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetBiometricTypes/getBiometricTypes outputTemplate: masterdata/GetBiometricTypes/getBiometricTypesResult @@ -9,5 +10,4 @@ GetBiometricTypes: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml index 5967d1db49e..a9b05937973 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml @@ -2,6 +2,7 @@ GetBiometricTypesByLangcode: Masterdata_GetBiometricTypesByLangcode_allValid_smoke: endPoint: /v1/masterdata/biometrictypes/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcode diff --git a/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml b/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml index 64ca411cef0..8c9144fa487 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml +++ b/automationtests/src/main/resources/masterdata/GetDocCategory/GetDocCategory.yml @@ -2,6 +2,7 @@ GetDocCategory: Admin_GetDocCategory_allValid_smoke: endPoint: /v1/masterdata/documentcategories role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetDocCategory/getDocCategory outputTemplate: masterdata/GetDocCategory/getDocCategoryResult diff --git a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml index cf0dfa9cd16..ee7c8b5206a 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/GetDocCategoryByLangCode.yml @@ -2,6 +2,7 @@ GetDocCategoryByLangCode: Admin_GetDocCategoryByLangCode_allValid_smoke: endPoint: /v1/masterdata/documentcategories/{code}/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCode outputTemplate: masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult diff --git a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml index e5510906ffb..7b2f4207bba 100644 --- a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml @@ -2,6 +2,7 @@ GetDocumentTypeByLangCode: Masterdata_GetDocumentTypeByLangCode_allValid_smoke: endPoint: /v1/masterdata/documenttypes/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCode outputTemplate: masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult diff --git a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml index b77fd17f631..d311ea8b621 100644 --- a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml +++ b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/GetExceptionalHolidays.yml @@ -2,6 +2,7 @@ GetExceptionalHolidays: Admin_GetExceptionalHolidays_allValid_smoke: endPoint: /v1/masterdata/exceptionalholidays/{registrationCenterId}/{langCode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langCode"] restMethod: get inputTemplate: masterdata/GetExceptionalHolidays/getExceptionalHolidays diff --git a/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/GetHolidaysMissingIds.yml b/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/GetHolidaysMissingIds.yml index 036d83d2848..9eb0a8d4ce0 100644 --- a/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/GetHolidaysMissingIds.yml +++ b/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/GetHolidaysMissingIds.yml @@ -2,6 +2,7 @@ GetHolidaysMissingIds: Admin_GetHolidaysMissingIds_allValid_smoke: endPoint: /v1/masterdata/holidays/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/GetHolidaysMissingIds/getHolidaysMissingIds diff --git a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml index a8e29e4cd3f..4423ef4cf4c 100644 --- a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml @@ -2,6 +2,7 @@ GetIdTypeByLangCode: Admin_GetIdTypeByLangCode_allValid_smoke: endPoint: /v1/masterdata/idtypes/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetIdTypeByLangCode/getIdTypeByLangCode outputTemplate: masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult diff --git a/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml b/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml index 1dc8f0c0736..f120bedb85f 100644 --- a/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml +++ b/automationtests/src/main/resources/masterdata/GetLanguage/GetLanguage.yml @@ -2,6 +2,7 @@ GetLanguage: Admin_GetLanguage_allValid_smoke: endPoint: /v1/masterdata/languages role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetLanguage/getLanguage outputTemplate: masterdata/GetLanguage/getLanguageResult @@ -12,7 +13,7 @@ GetLanguage: "languages": [{ "code": "$IGNORE$", "name": "$IGNORE$", - "family": "$IGNORE", + "family": "$IGNORE$", "nativeName": "$IGNORE$", "isActive": "$IGNORE$" }] diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml index a028634552f..2c0288b7ff6 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/GetLocationHierarchyLevelByLastUpdatedDate.yml @@ -2,6 +2,7 @@ GetLocationHierarchyLevelByLastUpdatedDate: Admin_GetLocationHierarchyLevelByLastUpdatedDate_allValid_smoke: endPoint: /v1/masterdata/locationHierarchyLevels?lastUpdated=2020-10-20T17:13:44.793Z role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDate outputTemplate: masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult diff --git a/automationtests/src/main/resources/masterdata/GetLocations/GetLocations.yml b/automationtests/src/main/resources/masterdata/GetLocations/GetLocations.yml index 3a642a08498..00c12053167 100644 --- a/automationtests/src/main/resources/masterdata/GetLocations/GetLocations.yml +++ b/automationtests/src/main/resources/masterdata/GetLocations/GetLocations.yml @@ -2,6 +2,7 @@ GetLocations: Admin_GetLocations_allValid_smoke: endPoint: /v1/masterdata/locations/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetLocations/getLocations outputTemplate: masterdata/GetLocations/getLocationsResult diff --git a/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml b/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml index 778430b20d7..6d5507b02ed 100644 --- a/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml +++ b/automationtests/src/main/resources/masterdata/GetMachines/GetMachines.yml @@ -2,6 +2,7 @@ GetMachines: Admin_GetMachines_allValid_smoke: endPoint: /v1/masterdata/machines role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetMachines/getMachines outputTemplate: masterdata/GetMachines/getMachinesResult diff --git a/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/GetMappedMachinesByRegCentID.yml b/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/GetMappedMachinesByRegCentID.yml index a9168243c92..123f3944cb7 100644 --- a/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/GetMappedMachinesByRegCentID.yml +++ b/automationtests/src/main/resources/masterdata/GetMappedMachinesByRegCentID/GetMappedMachinesByRegCentID.yml @@ -2,6 +2,7 @@ GetMappedMachinesByRegCentID: Admin_GetMappedMachinesByRegCentID_allValid_smoke: endPoint: /v1/masterdata/machines/mappedmachines/{regCenterId} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetMappedMachinesByRegCentID/getMappedMachinesByRegCentID outputTemplate: masterdata/GetMappedMachinesByRegCentID/getMappedMachinesByRegCentIDResult diff --git a/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/GetMissingDocumentCategoryByLangcode.yml b/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/GetMissingDocumentCategoryByLangcode.yml index 7271d950e4c..a3ed21b0876 100644 --- a/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/GetMissingDocumentCategoryByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/GetMissingDocumentCategoryByLangcode.yml @@ -2,6 +2,7 @@ GetMissingDocumentCategoryByLangcode: Masterdata_GetMissingDocumentCategoryByLangcode_allValid_smoke: endPoint: /v1/masterdata/documentcategories/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcode diff --git a/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/GetMissingDocumentTypeByLangcode.yml b/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/GetMissingDocumentTypeByLangcode.yml index 584bd75afc4..a7b00665f16 100644 --- a/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/GetMissingDocumentTypeByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/GetMissingDocumentTypeByLangcode.yml @@ -2,10 +2,11 @@ GetMissingDocumentTypeByLangcode: Masterdata_GetDocumentTypeByLangCode_all_valid_smoke: endPoint: /v1/masterdata/documenttypes/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcode - outputTemplate: masterdata/error + outputTemplate: masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult input: '{ "langcode":"eng" }' diff --git a/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/GetPacketRejectionReason.yml b/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/GetPacketRejectionReason.yml index 8993b4895db..175043187a5 100644 --- a/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/GetPacketRejectionReason.yml +++ b/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/GetPacketRejectionReason.yml @@ -2,6 +2,7 @@ GetPacketRejectionReason: Masterdata_GetPacketRejectionReason_allValid_smoke: endPoint: /v1/masterdata/packetrejectionreasons/{reasoncategorycode}/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/GetPacketRejectionReason/getPacketRejectionReason diff --git a/automationtests/src/main/resources/masterdata/GetPossiableValues/GetPossiableValues.yml b/automationtests/src/main/resources/masterdata/GetPossiableValues/GetPossiableValues.yml index 3d1893dbe6f..9e220d46e20 100644 --- a/automationtests/src/main/resources/masterdata/GetPossiableValues/GetPossiableValues.yml +++ b/automationtests/src/main/resources/masterdata/GetPossiableValues/GetPossiableValues.yml @@ -2,6 +2,7 @@ GetPossiableValues: Admin_GetPossiableValues_allValid_smoke: endPoint: /v1/masterdata/possiblevalues/{fieldName}?langCode=eng role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetPossiableValues/getPossiableValues outputTemplate: masterdata/GetPossiableValues/getPossiableValuesResult @@ -19,6 +20,7 @@ GetPossiableValues: Admin_GetPossiableValues_Invalid_Invalid_FieldName: endPoint: /v1/masterdata/possiblevalues/{fieldName}?langCode=eng role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetPossiableValues/getPossiableValues outputTemplate: masterdata/error @@ -37,6 +39,7 @@ GetPossiableValues: Admin_GetPossiableValues_Invalid_Invalid_langCode: endPoint: /v1/masterdata/possiblevalues/{fieldName}?langCode=abc role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetPossiableValues/getPossiableValues outputTemplate: masterdata/error diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml b/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml index 1b8718b9bcf..7b33e161cae 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml @@ -9,7 +9,6 @@ GetUserDetails: "id":"$REMOVE$" }' output: '{ - "id": "auto_test_user", "langCode": "eng", "name": "$IGNORE$", "statusCode": "$IGNORE$", @@ -27,7 +26,6 @@ GetUserDetails: "id":"func_auto_test_user" }' output: '{ - "id": "func_auto_test_user", "langCode": "eng", "name": "$IGNORE$", "statusCode": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs index 78405243db3..4ded4bbf36c 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs @@ -1,6 +1,5 @@ { "response": { - "id": "{{id}}", "langCode": "{{langCode}}", "regCenterId": "{{regCenterId}}" } diff --git a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml index f434564b288..58baf038480 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml +++ b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml @@ -187,7 +187,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "$LOCATIONCODE$", + "locationCode": "SOS", "requesttime": "$TIMESTAMP$" }' output: '{ diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml b/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml index 4bf159b37ff..165417e27b4 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml @@ -26,7 +26,7 @@ CreateRegistrationCenter: "perKioskProcessTime":"00:30:00", "timeZone":"(GTM+01:00) CENTRAL EUROPEAN TIME", "workingHours":3.5, - "zoneCode":"CSB", + "zoneCode":"$ZONE_CODE$", "id":"", "isActive":"false", "numberOfKiosks":0, @@ -67,7 +67,7 @@ CreateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"STT", + "zoneCode":"$ZONE_CODE$", "id": "96874", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", @@ -111,7 +111,7 @@ CreateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"STT", + "zoneCode":"$ZONE_CODE$", "id": "96874", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", @@ -154,7 +154,7 @@ CreateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"STT", + "zoneCode":"$ZONE_CODE$", "id": "96874", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml b/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml index 36cbea20f16..b0ecc3ae72c 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml @@ -2,6 +2,7 @@ UpdateRegistrationCenter: MasterData_UpdateRegistrationCenter_allValid_smoke: endPoint: /v1/masterdata/registrationcenters role: admin + checkErrorsOnlyInResponse: true templateFields: ["name","addressLine1","addressLine2","addressLine3","timeZone","langCode"] restMethod: put inputTemplate: masterdata/RegistrationCenter/registrationCenter @@ -27,7 +28,7 @@ UpdateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"CSB", + "zoneCode":"$ZONE_CODE$", "id": "$ID:CreateRegCenter_allValid_smoke_sid_id$", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", @@ -65,7 +66,7 @@ UpdateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"STT", + "zoneCode":"$ZONE_CODE$", "id": "123414", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", @@ -109,7 +110,7 @@ UpdateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"STT", + "zoneCode":"$ZONE_CODE$", "id": "96874", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", @@ -152,7 +153,7 @@ UpdateRegistrationCenter: "perKioskProcessTime": "00:15:00", "timeZone": "Test Time zone", "workingHours": "8:00:00", - "zoneCode":"STT", + "zoneCode":"$ZONE_CODE$", "id": "96874", "exceptionHolidayDate": "2020-11-16", "exceptionHolidayName": "TestHoliday", diff --git a/automationtests/src/main/resources/masterdata/SearchDynamicField/SearchDynamicField.yml b/automationtests/src/main/resources/masterdata/SearchDynamicField/SearchDynamicField.yml index 181b3e52b6b..caec7951333 100644 --- a/automationtests/src/main/resources/masterdata/SearchDynamicField/SearchDynamicField.yml +++ b/automationtests/src/main/resources/masterdata/SearchDynamicField/SearchDynamicField.yml @@ -2,6 +2,7 @@ SearchDynamicField: MasterData_SearchDynamicField_Valid_Smoke: endPoint: /v1/masterdata/dynamicfields/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchDynamicField/searchDynamicField @@ -23,6 +24,7 @@ SearchDynamicField: MasterData_SearchDynamicField_Valid_Filter_Name: endPoint: /v1/masterdata/dynamicfields/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchDynamicField/searchDynamicField diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml index 3f7837061f5..e8dbfcbdd8d 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml @@ -130,7 +130,7 @@ SearchMachine: "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } @@ -174,7 +174,7 @@ SearchMachine: "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } @@ -218,7 +218,7 @@ SearchMachine: "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } @@ -521,7 +521,7 @@ SearchMachine: "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", "langCode": "$IGNORE$", - "zoneCode": "CST", + "zoneCode": "$ZONE_CODE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } diff --git a/automationtests/src/main/resources/masterdata/SearchTemplateDetails/SearchTemplateDetails.yml b/automationtests/src/main/resources/masterdata/SearchTemplateDetails/SearchTemplateDetails.yml index cd48d600ecb..21a2d9cc70e 100644 --- a/automationtests/src/main/resources/masterdata/SearchTemplateDetails/SearchTemplateDetails.yml +++ b/automationtests/src/main/resources/masterdata/SearchTemplateDetails/SearchTemplateDetails.yml @@ -2,6 +2,7 @@ SearchTemplateDetails: MasterData_SearchTemplateDetails_ColumnName_Name_LangCode_eng_smoke: endPoint: /v1/masterdata/templates/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchTemplateDetails/searchTemplateDetails @@ -31,6 +32,7 @@ SearchTemplateDetails: MasterData_SearchTemplateDetails_ColumnName_Name_LangCode_eng_filterType_contain: endPoint: /v1/masterdata/templates/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/SearchTemplateDetails/searchTemplateDetails @@ -128,6 +130,7 @@ SearchTemplateDetails: MasterData_SearchTemplateDetails_ColumnName_Name_LangCode_eng_filterType_startsWith_filterValue_invalid: endPoint: /v1/masterdata/templates/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchTemplateDetails/searchTemplateDetails @@ -157,6 +160,7 @@ SearchTemplateDetails: MasterData_SearchTemplateDetails_ColumnName_Name_LangCode_eng_filterType_equals_filterValue_invalid: endPoint: /v1/masterdata/templates/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchTemplateDetails/searchTemplateDetails @@ -186,6 +190,7 @@ SearchTemplateDetails: MasterData_SearchTemplateDetails_ColumnName_Name_LangCode_eng_filterType_contains_filterValue_invalid: endPoint: /v1/masterdata/templates/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchTemplateDetails/searchTemplateDetails diff --git a/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml b/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml index 419624162d7..c2a02ba6c07 100644 --- a/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml +++ b/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml @@ -2,6 +2,7 @@ CreateTemplate: MasterData_CreateTemplate_All_Valid_Smoke_sid: endPoint: /v1/masterdata/templates role: admin + checkErrorsOnlyInResponse: true templateFields: ["description","name"] restMethod: post inputTemplate: masterdata/Template/template @@ -21,7 +22,7 @@ CreateTemplate: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "445566777", + "id": "$IGNORE$", "langCode": "$IGNORE$" }' MasterData_CreateTemplate_InputParameter_Name_Missing: diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/UpdateDeviceTypeStatus.yml b/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/UpdateDeviceTypeStatus.yml index f3743507bb6..eafbaa7e054 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/UpdateDeviceTypeStatus.yml +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/UpdateDeviceTypeStatus.yml @@ -12,4 +12,23 @@ UpdateDeviceTypeStatus: }' output: '{ "status": "Status updated successfully for Device Types" +}' + + MasterData_UpdateDeviceTypeStatus_TO_Verify_Deactivation: + endPoint: /v1/masterdata/devicetypes?isActive={isActive}&code={code} + role: admin + templateFields: [] + restMethod: patch + inputTemplate: masterdata/UpdateDeviceTypeStatus/updateDeviceTypeStatus + outputTemplate: masterdata/error + input: '{ + "code": "FRS", + "isActive": "false" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-055" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/UpdateHolidayStatus.yml b/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/UpdateHolidayStatus.yml index 680089629c1..afaeca3b09b 100644 --- a/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/UpdateHolidayStatus.yml +++ b/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/UpdateHolidayStatus.yml @@ -12,4 +12,19 @@ UpdateHolidayStatus: }' output: '{ "status": "Status updated successfully for holiday" +}' + + MasterData_UpdateHolidayStatus_TO_Verify_Deactivation_Neg: + endPoint: /v1/masterdata/holidays?holidayId={holidayId}&isActive={isActive} + role: admin + templateFields: [] + restMethod: patch + inputTemplate: masterdata/UpdateHolidayStatus/updateHolidayStatus + outputTemplate: masterdata/UpdateHolidayStatus/updateHolidayStatusResult + input: '{ + "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", + "isActive": "false" +}' + output: '{ + "status": "Status updated successfully for holiday" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml b/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml index 54c163a83a8..0e4c4f8adf4 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml @@ -15,7 +15,6 @@ UpdateUserCenterMapping: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "func_auto_test_user", "langCode": "eng", "name": "automationUpdated", "statusCode": "active", diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml b/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml index 21bb134e3c6..df18a797442 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml @@ -16,7 +16,6 @@ UserCenterMapping: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "func_auto_test_user", "langCode": "eng", "name": "automation", "statusCode": "active", diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/updateUserCenterMapping.hbs b/automationtests/src/main/resources/masterdata/UserCenterMapping/updateUserCenterMapping.hbs index 9ef6b75b415..77e6b471ce5 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/updateUserCenterMapping.hbs +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/updateUserCenterMapping.hbs @@ -2,7 +2,6 @@ "id": "string", "metadata": {}, "request": { - "id": "{{id}}", "name": "{{name}}", "statusCode": "{{statusCode}}", "regCenterId": "{{regCenterId}}", diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs index 544dac6f1f4..0e26dfc441d 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs @@ -1,6 +1,5 @@ { "response": { - "id": "{{id}}", "langCode": "{{langCode}}", "name": "{{name}}", "statusCode": "{{statusCode}}", diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentSearch/ValidDocumentSearch.yml b/automationtests/src/main/resources/masterdata/ValidDocumentSearch/ValidDocumentSearch.yml index 0b64c28698d..c5d218b0408 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentSearch/ValidDocumentSearch.yml +++ b/automationtests/src/main/resources/masterdata/ValidDocumentSearch/ValidDocumentSearch.yml @@ -2,6 +2,7 @@ ValidDocumentSearch: MasterData_ValidDocumentSearch_Valid_Smoke: endPoint: /v1/masterdata/validdocuments/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/ValidDocumentSearch/validDocumentSearch @@ -18,11 +19,11 @@ ValidDocumentSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "errors": null }' MasterData_ValidDocumentSearch_Valid_Filter_DocCatcode: endPoint: /v1/masterdata/validdocuments/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/ValidDocumentSearch/validDocumentSearch @@ -43,7 +44,6 @@ ValidDocumentSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "errors": null }' MasterData_ValidDocumentSearch_Invalid_NegPageFetch: endPoint: /v1/masterdata/validdocuments/search diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml b/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml index defdbc91deb..e6fb3ebb3e8 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/ZoneUser/CreateZoneUser.yml @@ -2,6 +2,7 @@ CreateZoneUser: MasterData_CreateZoneUser_All_Valid_Smoke: endPoint: /v1/masterdata/zoneuser role: globalAdmin + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: masterdata/ZoneUser/zoneUser outputTemplate: masterdata/ZoneUser/zoneUserResult @@ -13,8 +14,7 @@ CreateZoneUser: "requesttime": "$TIMESTAMP$" }' output: '{ - "zoneCode": "$ZONE_CODE$", - "userId": "func_auto_test_user" + }' MasterData_CreateZoneUser__Empty_UserID_Valid: diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml b/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml index ef19caea8fa..8477b791ecb 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/ZoneUser/UpdateZoneUser.yml @@ -2,6 +2,7 @@ UpdateZoneUser: MasterData_UpdateZoneUser_All_Valid_Smoke: endPoint: /v1/masterdata/zoneuser role: globalAdmin + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: masterdata/ZoneUser/updateZoneUser outputTemplate: masterdata/ZoneUser/zoneUserResult @@ -11,6 +12,5 @@ UpdateZoneUser: "requesttime": "$TIMESTAMP$" }' output: '{ - "zoneCode": "$ZONE_CODE$", - "userId": "func_auto_test_user" + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs b/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs index 903ab78f706..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs @@ -1,6 +1,2 @@ { - "response": { - "zoneCode": "{{zoneCode}}", - "userId": "{{userId}}" - } } \ No newline at end of file From 4a8ca6a47b7e790a9c1005586c9cd3e602689cf2 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 14 Sep 2023 12:16:52 +0530 Subject: [PATCH 145/204] MOSIP-29286 --- .../testNgXmlFiles/authenticationApi.xml | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index 8d3a321f28a..25b6ead13af 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -188,6 +188,24 @@ + + + + + + + + + + + + + + + + From a4d411be0ec68d6bcb1a42d490632e3e58e9527e Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Thu, 14 Sep 2023 15:26:03 +0530 Subject: [PATCH 146/204] resolve --- .../BiometricAttributes.yml | 3 +- .../biometricAttributesResult.hbs | 3 +- .../CreateBlockListedWords.yml | 3 +- .../UpdateBlockListedWords.yml | 3 +- .../blockListedWordsResult.hbs | 3 +- .../CreateApplicationType.yml | 4 +- .../createApplicationTypeResult.hbs | 3 +- .../CreateBiometricType.yml | 4 +- .../createBiometricTypeResult.hbs | 3 +- .../masterdata/CreateIdType/CreateIdType.yml | 4 +- .../CreateIdType/createIdTypeResult.hbs | 3 +- .../DeleteHoliday/deleteHoliday.yml | 14 +++---- .../DeleteLanguage/DeleteLanguage.yml | 2 +- .../DeleteLocation/DeleteLocation.yml | 5 ++- .../masterdata/Device/CreateDevice.yml | 6 +-- .../masterdata/Device/UpdateDevice.yml | 6 +-- .../masterdata/Device/createDeviceResult.hbs | 1 - .../masterdata/DeviceSearch/DeviceSearch.yml | 2 - .../DeviceSearch/deviceSearchResult.hbs | 1 - .../deviceSpecSearchResult.hbs | 1 - .../CreateDeviceSpecification.yml | 4 +- .../UpdateDeviceSpecification.yml | 4 +- .../deviceSpecificationResult.hbs | 3 +- .../DeviceType/CreateDeviceType.yml | 9 ++--- .../DeviceType/UpdateDeviceType.yml | 6 +-- .../DeviceType/deviceTypeResult.hbs | 3 +- .../deviceTypeSearchResult.hbs | 1 - .../CreateDocumentCategory.yml | 6 +-- .../UpdateDocumentCategory.yml | 6 +-- .../documentCategoryResult.hbs | 3 +- .../DocumentType/CreateDocumentType.yml | 2 - .../DocumentType/UpdateDocumentType.yml | 1 - .../DocumentType/documentTypeResult.hbs | 1 - .../FetchBlockListedWordByLangcode.yml | 1 - .../fetchBlockListedWordByLangcodeResult.hbs | 10 ----- .../masterdata/FetchDevice/FetchDevice.yml | 20 +--------- .../FetchDevice/fetchDeviceByCenterResult.hbs | 37 +++---------------- .../FetchDevice/fetchDeviceResult.hbs | 10 +---- .../FetchDistinctDynamicFieldByLangcode.yml | 1 - .../fetchDocumentCategoriesResult.hbs | 1 - .../fetchDocumentTypesResult.hbs | 1 - .../fetchDocumentTypesbylangcodeResult.hbs | 1 - .../FetchHolidays/fetchHolidayResult.hbs | 1 - .../FetchLocation/FetchLocation.yml | 4 +- .../fetchLocationImmediatechildrenResult.hbs | 11 +----- .../FetchLocationHierarchy.yml | 2 - .../fetchLocationHierarchyResult.hbs | 1 - .../masterdata/FetchModule/FetchModule.yml | 4 +- .../FetchModule/fetchModuleResult.hbs | 11 +----- .../fetchRegCentHolidayResult.hbs | 6 --- .../FetchRegCent/fetchRegCentResult.hbs | 11 +----- .../FetchRegCentHistory.yml | 1 - .../fetchRegCentHistoryResult.hbs | 1 - .../FetchTemplate/FetchTemplate.yml | 1 - .../FetchTemplate/fetchTemplateResult.hbs | 1 - .../masterdata/FetchTitle/FetchTitle.yml | 6 +-- .../FetchTitle/fetchTitleResult.hbs | 3 +- .../FilterRegCenterType.yml | 2 +- .../masterdata/Gender/CreateGender.yml | 3 +- .../masterdata/Gender/UpdateGender.yml | 3 +- .../masterdata/Gender/genderResult.hbs | 3 +- .../GetApplicationTypeByCodeAndLangcode.yml | 3 +- ...ApplicationTypeByCodeAndLangcodeResult.hbs | 3 +- .../GetApplicationTypes.yml | 2 +- .../GetApplicationTypesByLangcode.yml | 9 +---- .../getApplicationTypesByLangcodeResult.hbs | 10 ----- .../GetBiometricAttributesByAuthType.yml | 1 - ...getBiometricAttributesByAuthTypeResult.hbs | 3 +- .../GetBiometricTypeByCodeAndLangcode.yml | 9 ++--- ...etBiometricTypeByCodeAndLangcodeResult.hbs | 3 +- .../GetBiometricTypesByLangcode.yml | 8 +--- .../getBiometricTypesByLangcodeResult.hbs | 10 ----- .../GetDeviceHistory/GetDeviceHistory.yml | 1 - .../getDeviceHistoryResult.hbs | 1 - .../GetDocCategory/getDocCategoryResult.hbs | 1 - .../getDocCategoryByLangCodeResult.hbs | 1 - .../GetDocType_DocCatByAppID.yml | 2 - .../getDocType_DocCatByAppIDResult.hbs | 2 - .../GetDocumentTypeByLangCode.yml | 1 - .../getDocumentTypeByLangCodeResult.hbs | 1 - .../GetIdTypeByLangCode.yml | 1 - .../getIdTypeByLangCodeResult.hbs | 1 - .../GetLeafZonesByLangCode.yml | 2 +- .../getLeafZonesByLangCodeResult.hbs | 5 +-- .../GetLeafsByLangCode/GetLeafsByLangCode.yml | 2 +- .../getLeafsByLangCodeResult.hbs | 3 -- .../GetLocationHierarchyByHierarchyName.yml | 1 - ...LocationHierarchyByHierarchyNameResult.hbs | 1 - ...nHierarchyLevelByLastUpdatedDateResult.hbs | 1 - .../GetMachineHistory/GetMachineHistory.yml | 2 +- .../getMachineHistoryResult.hbs | 1 - .../GetMachines/getMachinesResult.hbs | 1 - .../GetSubZoneByLangCode.yml | 1 - .../getSubZoneByLangCodeResult.hbs | 3 -- .../GetTemplates/getTemplatesResult.hbs | 1 - .../GetUserDetails/GetUserDetails.yml | 2 - .../getUserDetailsByIDResult.hbs | 1 - .../GetUserDetails/getUserDetailsResult.hbs | 1 - .../GetUserDetailsByIdAndEffDate.yml | 3 +- .../getUserDetailsByIdAndEffDateResult.hbs | 3 +- .../GetValidDocument/GetValidDocument.yml | 2 +- .../getValidDocumentResult.hbs | 3 -- .../masterdata/GetWeekDay/GetWeekDay.yml | 2 +- .../GetZoneHierarchyByLangCode.yml | 2 +- .../GetimmediateChildrenByLocationCode.yml | 2 +- ...timmediateChildrenByLocationCodeResult.hbs | 1 - .../masterdata/Holiday/CreateHoliday.yml | 2 +- .../masterdata/Holiday/UpdateHoliday.yml | 2 +- .../masterdata/Holiday/holidayResult.hbs | 3 +- .../masterdata/Machine/CreateMachine.yml | 3 +- .../masterdata/Machine/UpdateMachine.yml | 2 +- .../masterdata/Machine/machineResult.hbs | 1 - .../CreateMachineSpecification.yml | 4 +- .../MachineSpecificationResult.hbs | 3 +- .../UpdateMachineSpecification.yml | 4 +- .../MachineType/CreateMachineType.yml | 3 +- .../MachineType/UpdateMachineType.yml | 3 +- .../MachineType/machineTypeResult.hbs | 3 +- .../MachineTypeSearch/MachineTypeSearch.yml | 1 - .../machineTypeSearchResult.hbs | 1 - .../PacketRejectionReasonCategory.yml | 3 +- .../packetRejectionReasonCategoryResult.hbs | 3 +- .../PacketRejectionReasonList.yml | 3 +- .../packetRejectionReasonListResult.hbs | 3 +- .../RegCenterSearch/RegCenterSearch.yml | 3 +- .../RegCenterSearch/regCenterSearchResult.hbs | 3 +- .../RegCenterType/UpdateRegCenterType.yml | 6 +-- .../RegCenterType/regCenterTypeResult.hbs | 3 +- .../RejectionList/RejectionList.yml | 1 - .../RejectionList/rejectionListResult.hbs | 3 +- .../SearchBlockListedWords.yml | 12 ++---- .../searchBlockListedWordsResult.hbs | 1 - .../SearchDocCategories.yml | 1 - .../searchDocCategoriesResult.hbs | 1 - .../searchDocumentTypeResult.hbs | 1 - .../SearchMachine/SearchMachine.yml | 12 ++---- .../SearchMachine/searchMachineResult.hbs | 1 - .../SearchMachineSpec/SearchMachineSpec.yml | 6 --- .../searchMachineSpecResult.hbs | 1 - .../SearchZoneUser/SearchZoneUser.yml | 1 - .../SearchZoneUser/searchZoneUserResult.hbs | 1 - .../masterdata/Template/CreateTemplate.yml | 3 +- .../masterdata/Template/UpdateTemplate.yml | 3 +- .../masterdata/Template/templateResult.hbs | 3 +- .../CreateTemplateFileFormat.yml | 3 +- .../UpdateTemplateFileFormat.yml | 3 +- .../templateFileFormatResult.hbs | 3 +- .../TemplateType/CreateTemplateType.yml | 3 +- .../TemplateType/templateTypeResult.hbs | 3 +- .../masterdata/Title/CreateTitle.yml | 3 +- .../masterdata/Title/UpdateTitle.yml | 3 +- .../masterdata/Title/titleResult.hbs | 3 +- .../masterdata/TitleSearch/TitleSearch.yml | 12 ++---- .../TitleSearch/titleSearchResult.hbs | 3 +- .../UpdateBlockListedWordDetails.yml | 3 +- .../updateblockListedWordDetailsResult.hbs | 3 +- .../UpdateRegistrationCenterLang.yml | 1 - .../updateRegistrationCenterResult.hbs | 1 - .../UpdateUserCenterMapping.yml | 1 - .../UserCenterMapping/UserCenterMapping.yml | 1 - .../userCenterMappingResult.hbs | 1 - 161 files changed, 132 insertions(+), 430 deletions(-) diff --git a/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml b/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml index aaf941a200d..0814f347a5c 100644 --- a/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml +++ b/automationtests/src/main/resources/masterdata/BiometricAttributes/BiometricAttributes.yml @@ -17,8 +17,7 @@ BiometricAttributes: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "TST", - "langCode": "eng" + "code": "TST" }' MasterData_BiometricAttributes_Invalid_empty_biometricTypeCode: diff --git a/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs b/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs index f7055122245..31017c0687f 100644 --- a/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs +++ b/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/CreateBlockListedWords.yml b/automationtests/src/main/resources/masterdata/BlockListedWords/CreateBlockListedWords.yml index 96a4d0eee0d..83aec4c7a46 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/CreateBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/CreateBlockListedWords.yml @@ -14,8 +14,7 @@ CreateBlockListedWords: "requesttime": "$TIMESTAMP$" }' output: '{ - "word": "dumboo", - "langCode": "eng" + "word": "dumboo" }' Masterdata_CreateBlockListedWords_space_in_word: endPoint: /v1/masterdata/blocklistedwords diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml b/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml index 923729591d2..5a5042f9378 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml @@ -15,8 +15,7 @@ UpdateBlockListedWords: "requesttime": "$TIMESTAMP$" }' output: '{ - "word": "dumbooo", - "langCode": "eng" + "word": "dumbooo" }' Masterdata_UpdateBlockListedWords_with_spaces: endPoint: /v1/masterdata/blocklistedwords diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs index e0205766751..660bddf4626 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs @@ -1,6 +1,5 @@ { "response":{ -"word":"{{word}}", -"langCode":"{{langCode}}" +"word":"{{word}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateApplicationType/CreateApplicationType.yml b/automationtests/src/main/resources/masterdata/CreateApplicationType/CreateApplicationType.yml index 4196a5e817b..872f6967143 100644 --- a/automationtests/src/main/resources/masterdata/CreateApplicationType/CreateApplicationType.yml +++ b/automationtests/src/main/resources/masterdata/CreateApplicationType/CreateApplicationType.yml @@ -14,7 +14,5 @@ CreateApplicationType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "dumbo", - "langCode": "eng", - "errors": null + "code": "dumbo" }' diff --git a/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateBiometricType/CreateBiometricType.yml b/automationtests/src/main/resources/masterdata/CreateBiometricType/CreateBiometricType.yml index d539bd5aad9..8af1c01f8e3 100644 --- a/automationtests/src/main/resources/masterdata/CreateBiometricType/CreateBiometricType.yml +++ b/automationtests/src/main/resources/masterdata/CreateBiometricType/CreateBiometricType.yml @@ -14,7 +14,5 @@ CreateBiometricTypes: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "dumbo6", - "langCode": "eng", - "errors": null + "code": "dumbo6" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateIdType/CreateIdType.yml b/automationtests/src/main/resources/masterdata/CreateIdType/CreateIdType.yml index 6f2461f8fca..c88db1f0157 100644 --- a/automationtests/src/main/resources/masterdata/CreateIdType/CreateIdType.yml +++ b/automationtests/src/main/resources/masterdata/CreateIdType/CreateIdType.yml @@ -14,9 +14,7 @@ CreateIdType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "NEW", - "langCode": "eng", - "errors": null + "code": "NEW" }' MasterData_CreateIdType_Invalid_langCode: endPoint: /v1/masterdata/idtypes diff --git a/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs index f7055122245..31017c0687f 100644 --- a/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHoliday.yml b/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHoliday.yml index 922d931ba38..594ff468708 100644 --- a/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHoliday.yml +++ b/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHoliday.yml @@ -9,11 +9,11 @@ DeleteHoliday: input: '{ "requesttime": "$TIMESTAMP$", "holidayDate": "2020-08-15", - "locationCode": "KTA" + "locationCode": "$LOCATIONCODE$" }' output: '{ "holidayDate": "2020-08-15", - "locationCode": "KTA" + "locationCode": "$IGNORE$" }' MasterData_DeleteHoliday_Invalid_requesttime_Neg: @@ -26,7 +26,7 @@ DeleteHoliday: input: '{ "requesttime": "ssf$5", "holidayDate": "2020-08-15", - "locationCode": "KTA" + "locationCode": "$LOCATIONCODE$" }' output: '{ "errors": [ @@ -36,7 +36,7 @@ DeleteHoliday: } ], "holidayDate": "2020-08-15", - "locationCode": "KTA" + "locationCode": "$IGNORE$" }' MasterData_DeleteHoliday_Invalid_locationCode: @@ -59,7 +59,7 @@ DeleteHoliday: } ], "holidayDate": "2020-08-15", - "locationCode": "KTA" + "locationCode": "$IGNORE$" }' MasterData_DeleteHoliday_Invalid_holidayDate_Neg: @@ -72,7 +72,7 @@ DeleteHoliday: input: '{ "requesttime": "$TIMESTAMP$", "holidayDate": "2020-0", - "locationCode": "KTA" + "locationCode": "$LOCATIONCODE$" }' output: '{ "errors": [ @@ -82,5 +82,5 @@ DeleteHoliday: } ], "holidayDate": "2020-08-15", - "locationCode": "KTA" + "locationCode": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteLanguage/DeleteLanguage.yml b/automationtests/src/main/resources/masterdata/DeleteLanguage/DeleteLanguage.yml index 4fcf9df81ae..d2cd3b1b51c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteLanguage/DeleteLanguage.yml +++ b/automationtests/src/main/resources/masterdata/DeleteLanguage/DeleteLanguage.yml @@ -2,6 +2,7 @@ DeleteLanguage: Masterdata_DeleteLanguage_All_Valid_Smoke: endPoint: /v1/masterdata/languages/{code} role: admin + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: masterdata/DeleteLanguage/deletelanguage outputTemplate: masterdata/DeleteLanguage/deletelanguageResult @@ -9,5 +10,4 @@ DeleteLanguage: "code": "$ID:CreateLanguage_All_Valid_Smoke_sid_code$" }' output: '{ - "error": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteLocation/DeleteLocation.yml b/automationtests/src/main/resources/masterdata/DeleteLocation/DeleteLocation.yml index 770b1585646..15e370988a8 100644 --- a/automationtests/src/main/resources/masterdata/DeleteLocation/DeleteLocation.yml +++ b/automationtests/src/main/resources/masterdata/DeleteLocation/DeleteLocation.yml @@ -2,14 +2,15 @@ DeleteLocation: MasterData_DeleteLocation_All_Valid_Smoke_sid: endPoint: /v1/masterdata/locations/{locationcode} role: admin + checkErrorsOnlyInResponse: true restMethod: delete inputTemplate: masterdata/DeleteLocation/deleteLocation outputTemplate: masterdata/DeleteLocation/deleteLocationResult input: '{ - "locationcode": "10114" + "locationcode": "$LOCATIONCODE$" }' output: '{ - "code": "10114" + "code": "$IGNORE$" }' MasterData_DeleteLocation_Invalid_ID: endPoint: /v1/masterdata/locations/{locationcode} diff --git a/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml b/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml index 9f0bcd81d62..984c45a0f98 100644 --- a/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml +++ b/automationtests/src/main/resources/masterdata/Device/CreateDevice.yml @@ -24,9 +24,8 @@ CreateDevice: "deviceSpecId": "743", "ipAddress": "172.23.174.113", "isActive": false, - "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -56,9 +55,8 @@ CreateDevice: "deviceSpecId": "736", "ipAddress": "172.23.174.113", "isActive": false, - "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" diff --git a/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml b/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml index a6ff614dba0..ac2f51dd9af 100644 --- a/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml +++ b/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml @@ -24,9 +24,8 @@ UpdateDevice: "deviceSpecId": "743", "ipAddress": "172.23.174.113", "isActive": "$IGNORE$", - "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" @@ -56,9 +55,8 @@ UpdateDevice: "deviceSpecId": "736", "ipAddress": "172.23.174.113", "isActive": "$IGNORE$", - "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "validityDateTime": "$TIMESTAMP$", "serialNum": "ceec5f62-77b7-46f3-816b-3e734305a9c8", "requesttime": "$TIMESTAMP$" diff --git a/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs b/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs index 67dab45f717..f5ac1defb5c 100644 --- a/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs @@ -5,7 +5,6 @@ "deviceSpecId":"{{deviceSpecId}}", "macAddress":"{{macAddress}}", "ipAddress":"{{ipAddress}}", - "langCode":"{{langCode}}", "validityDateTime":"{{validityDateTime}}", "isActive":"{{isActive}}" } diff --git a/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml b/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml index 20b7238db4c..49f1965013f 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSearch/DeviceSearch.yml @@ -36,7 +36,6 @@ DeviceSearch: "macAddress": "85-BB-97-4B-14-05", "ipAddress": "$IGNORE$", "deviceSpecId": "327", - "langCode": "$IGNORE$", "isActive": "$IGNORE$", "validityDateTime": "$IGNORE$" }] @@ -79,7 +78,6 @@ DeviceSearch: "macAddress": "85-BB-97-4B-14-05", "ipAddress": "$IGNORE$", "deviceSpecId": "327", - "langCode": "$IGNORE$", "isActive": "$IGNORE$", "validityDateTime": "$IGNORE$" }] diff --git a/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs index b05d6f3bb88..60b57fc90e3 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs @@ -10,7 +10,6 @@ "macAddress": "{{macAddress}}", "ipAddress": "{{ipAddress}}", "deviceSpecId": "{{deviceSpecId}}", - "langCode": "{{langCode}}", "validityDateTime": "{{validityDateTime}}", "isActive": "{{isActive}}" } diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs index 2dd22136683..1c1de3d3a74 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs @@ -5,7 +5,6 @@ { "isActive": "{{isActive}}", "id": "{{id}}", - "langCode": "{{langCode}}", "name": "{{name}}", "description": "{{description}}", "model": "{{model}}", diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml b/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml index 9cc1495dfcf..26a4e079a65 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecification/CreateDeviceSpecification.yml @@ -2,6 +2,7 @@ CreateDeviceSpecification: MasterData_CreateDeviceSpecification_All_Valid_Smoke_sid: endPoint: /v1/masterdata/devicespecifications role: admin + checkErrorsOnlyInResponse: true templateFields: ["name","description"] restMethod: post inputTemplate: masterdata/DeviceSpecification/deviceSpecification @@ -19,8 +20,7 @@ CreateDeviceSpecification: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$", - "langCode": "eng" + "id": "$IGNORE$" }' MasterData_CreateDeviceSpecification_Dublicate_DeviceSpecification_Neg: diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecification/UpdateDeviceSpecification.yml b/automationtests/src/main/resources/masterdata/DeviceSpecification/UpdateDeviceSpecification.yml index ab8fe4c2949..22aa546bcf7 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecification/UpdateDeviceSpecification.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecification/UpdateDeviceSpecification.yml @@ -2,6 +2,7 @@ UpdateDeviceSpecification: MasterData_UpdateDeviceSpecification_All_Valid_Smoke: endPoint: /v1/masterdata/devicespecifications role: admin + checkErrorsOnlyInResponse: true templateFields: ["name","description"] restMethod: put inputTemplate: masterdata/DeviceSpecification/deviceSpecification @@ -19,8 +20,7 @@ UpdateDeviceSpecification: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$", - "langCode": "eng" + "id": "$IGNORE$" }' MasterData_UpdateDeviceSpecification_InputParameter_Name_Missing: diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs index 9be53d201f0..b8eed36f548 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs @@ -1,6 +1,5 @@ { "response": { - "id": "{{id}}", - "langCode": "{{langCode}}" + "id": "{{id}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml index 73ddbb3b08a..6bd100b34e5 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml +++ b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml @@ -15,8 +15,7 @@ CreateDeviceType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "GST3", - "langCode": "eng" + "code": "GST3" }' MasterData_CreateDeviceType_TO_verify_Deactivation: @@ -35,8 +34,7 @@ CreateDeviceType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "ABC3", - "langCode": "eng" + "code": "ABC3" }' MasterData_CreateDeviceType_All_Valid_Mandatory_Fields: endPoint: /v1/masterdata/devicetypes @@ -54,8 +52,7 @@ CreateDeviceType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "GST4", - "langCode": "eng" + "code": "GST4" }' MasterData_CreateDeviceType_Dublicate_Device_Neg: diff --git a/automationtests/src/main/resources/masterdata/DeviceType/UpdateDeviceType.yml b/automationtests/src/main/resources/masterdata/DeviceType/UpdateDeviceType.yml index a8324c7ed5c..9b509cb680f 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/UpdateDeviceType.yml +++ b/automationtests/src/main/resources/masterdata/DeviceType/UpdateDeviceType.yml @@ -15,8 +15,7 @@ UpdateDeviceType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "GST3", - "langCode": "eng" + "code": "GST3" }' MasterData_UpdateDeviceType_All_Valid_Mandatory_Fields: endPoint: /v1/masterdata/devicetypes @@ -34,8 +33,7 @@ UpdateDeviceType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "GST4", - "langCode": "eng" + "code": "GST4" }' MasterData_UpdateDeviceType_InputParameter_Code_Missing: endPoint: /v1/masterdata/devicetypes diff --git a/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs index 2e609f360a2..153bad660de 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs @@ -6,7 +6,6 @@ "isActive": "{{isActive}}", "createdBy": "{{createdBy}}", "code": "{{code}}", - "langCode": "{{langCode}}", "name": "{{name}}", "description": "{{description}}" } diff --git a/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml b/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml index d56e288060d..b2283229fa7 100644 --- a/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml +++ b/automationtests/src/main/resources/masterdata/DocumentCategory/CreateDocumentCategory.yml @@ -15,8 +15,7 @@ CreateDocumentCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "DocTestCode123", - "langCode": "eng" + "code": "DocTestCode123" }' MasterData_CreateDocumentCategory_All_Valid_Mandatory_Fields: endPoint: /v1/masterdata/documentcategories @@ -34,8 +33,7 @@ CreateDocumentCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "DocTestCode321", - "langCode": "eng" + "code": "DocTestCode321" }' MasterData_CreateDocumentCategory_Invalid_InputParameter_Code_Missing: diff --git a/automationtests/src/main/resources/masterdata/DocumentCategory/UpdateDocumentCategory.yml b/automationtests/src/main/resources/masterdata/DocumentCategory/UpdateDocumentCategory.yml index 4aaf2ea37b5..f5074418a2e 100644 --- a/automationtests/src/main/resources/masterdata/DocumentCategory/UpdateDocumentCategory.yml +++ b/automationtests/src/main/resources/masterdata/DocumentCategory/UpdateDocumentCategory.yml @@ -15,8 +15,7 @@ UpdateDocumentCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "DocTestCode123", - "langCode": "eng" + "code": "DocTestCode123" }' MasterData_UpdateDocumentCategory_All_Valid_Mandatory_Fields: endPoint: /v1/masterdata/documentcategories @@ -34,8 +33,7 @@ UpdateDocumentCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "DocTestCode321", - "langCode": "eng" + "code": "DocTestCode321" }' MasterData_UpdateDocumentCategory_Invalid_InputParameter_Code_Missing: diff --git a/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs b/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml b/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml index 9b0b9f966ca..6ef680ffdbe 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml @@ -18,7 +18,6 @@ CreateDocumentType: "code": "TestDocType0010", "description": "TestDocType0010 Card Holder", "isActive": "$IGNORE$", - "langCode": "eng", "name": "TestDocType0010 Card" }' MasterData_CreateDocumentType_All_Valid_Mandatory_Fields_Eng: @@ -40,7 +39,6 @@ CreateDocumentType: "code": "TestDocType0020", "description": "$IGNORE$", "isActive": "$IGNORE$", - "langCode": "eng", "name": "TestDocType0020 Card" }' diff --git a/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml b/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml index da4c48da58b..e60abab9f40 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml @@ -18,7 +18,6 @@ UpdateDocumentType: "code": "TestDocType0010", "description": "TestDocType0010 Card Holder updated", "isActive": "$IGNORE$", - "langCode": "eng", "name": "TestDocType0010 Card" }' diff --git a/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs b/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs index 612373a2a9a..aebf9d53050 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs @@ -1,7 +1,6 @@ { "response":{ "code":"{{code}}", -"langCode":"{{langCode}}", "name":"{{name}}", "description":"{{description}}", "isActive":"{{isActive}}" diff --git a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml index d0988fa1167..87a50994fc4 100644 --- a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml @@ -11,7 +11,6 @@ FetchBlockListedWordByLangcode: "langCode": "eng" }' output: '{ - "langCode":"eng" }' Masterdata_FetchBlackListedWord_invalid_langcode: endPoint: /v1/masterdata/blocklistedwords/{langCode} diff --git a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs index 882d2764954..2c63c085104 100644 --- a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcodeResult.hbs @@ -1,12 +1,2 @@ { - "response":{ - "blocklistedwords":[ - {{#each blocklistedwords}} - { - "langCode":"{{langCode}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } } diff --git a/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml b/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml index fafcab83d84..3afdbd2c74f 100644 --- a/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml +++ b/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml @@ -13,15 +13,7 @@ FetchDevice: }' output: '{ "devices": [{ - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "deviceSpecId": "$IGNORE$", - "macAddress": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": true, - "deviceTypeCode": "$IGNORE$", - "zoneCode": "$IGNORE$", - "regCenterId": "$IGNORE$" + "isActive": true }] }' MasterData_FetchDevice_allValid_smoke_with_lang_and_deviceType: @@ -38,15 +30,7 @@ FetchDevice: }' output: '{ "devices": [{ - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "deviceSpecId": "$IGNORE$", - "macAddress": "$IGNORE$", - "langCode": "$IGNORE$", - "isActive": true, - "deviceTypeCode": "GST4", - "zoneCode": "$IGNORE$", - "regCenterId": "$IGNORE$" + "isActive": true }] }' MasterData_FetchDevice_allValid_smoke_with_regCentre: diff --git a/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceByCenterResult.hbs b/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceByCenterResult.hbs index 9a3f6e5dac3..fa8f1b97d34 100644 --- a/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceByCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceByCenterResult.hbs @@ -1,39 +1,12 @@ -{ - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "pageNo": "$IGNORE$", - "pageSize": "$IGNORE$", - "sort": { - "unsorted": "$IGNORE$", - "sorted": "$IGNORE$" - }, - "totalItems": "$IGNORE$", - "totalPages": "$IGNORE$", - "data": [ +{ + "data": [ {{#each data}} { - "isActive": {{isActive}}, - "createdBy": "$IGNORE$", - "createdDateTime": "$IGNORE$", - "updatedBy": "$IGNORE$", - "updatedDateTime": "$IGNORE$", - "isDeleted": "$IGNORE$", - "deletedDateTime": "$IGNORE$", - "regCentId": "$IGNORE$", - "id": "$IGNORE$", - "name": "$IGNORE$", - "serialNum": "$IGNORE$", - "deviceSpecId": "$IGNORE$", - "macAddress": "$IGNORE$", - "ipAddress": "$IGNORE$", - "langCode": "$IGNORE$" + "isActive": {{isActive}} + } {{#unless @last}},{{/unless}} {{/each}} ] - }, - "errors": "$IGNORE$" + } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs b/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs index da07441a7e8..1c6bdbce9f8 100644 --- a/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDevice/fetchDeviceResult.hbs @@ -3,15 +3,7 @@ "devices": [ {{#each devices}} { - "name": "{{name}}", - "serialNum": "{{serialNum}}", - "deviceSpecId": "{{deviceSpecId}}", - "macAddress": "{{macAddress}}", - "langCode": "{{langCode}}", - "isActive": {{isActive}}, - "deviceTypeCode": "{{deviceTypeCode}}", - "zoneCode": "{{zoneCode}}", - "regCenterId": "{{regCenterId}}" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml index 5b110e6d258..62600be0a36 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/FetchDistinctDynamicFieldByLangcode.yml @@ -10,5 +10,4 @@ FetchDistinctDynamicFieldByLangcode: "langCode":"eng" }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs index ad20b3b7310..11c724816bb 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/fetchDocumentCategoriesResult.hbs @@ -3,7 +3,6 @@ "documentcategories": [ {{#each documentcategories}} { - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs index cac1d9e7014..b7b8dc4bbd0 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs @@ -3,7 +3,6 @@ "documenttypes": [ {{#each documenttypes}} { - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs index cac1d9e7014..b7b8dc4bbd0 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs @@ -3,7 +3,6 @@ "documenttypes": [ {{#each documenttypes}} { - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs b/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs index d8cd9a79807..01e94963282 100644 --- a/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs @@ -3,7 +3,6 @@ "holidays": [ {{#each holidays}} { - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml b/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml index c0b11186dda..2a33172818c 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml +++ b/automationtests/src/main/resources/masterdata/FetchLocation/FetchLocation.yml @@ -218,6 +218,7 @@ FetchLocation: MasterData_FetchLocation_immediatechildren: endPoint: /v1/masterdata/locations/immediatechildren/{locationcode}/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchLocation/fetchLocation outputTemplate: masterdata/FetchLocation/fetchLocationImmediatechildrenResult @@ -228,7 +229,4 @@ FetchLocation: "hierarchyname": "$REMOVE$" }' output: '{ -"locations": [{ - "langCode": "eng" - }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs index 36beeea7f4e..c1860fa3b57 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs @@ -1,12 +1,3 @@ { - "response": { - "locations": [ - {{#each locations}} - { - "langCode": "{{langCode}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } + } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/FetchLocationHierarchy.yml b/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/FetchLocationHierarchy.yml index 8a5f762516e..59f0e3b1ea5 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/FetchLocationHierarchy.yml +++ b/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/FetchLocationHierarchy.yml @@ -11,7 +11,6 @@ FetchLocationHierarchy: }' output: '{ "locationHierarchyLevels": [{ - "langCode": "eng", "isActive": "true" }] }' @@ -45,7 +44,6 @@ FetchLocationHierarchy: }' output: '{ "locationHierarchyLevels": [{ - "langCode": "eng", "isActive": "true" }] }' diff --git a/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs index cde6820600d..6adff8110a5 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocationHierarchy/fetchLocationHierarchyResult.hbs @@ -3,7 +3,6 @@ "locationHierarchyLevels": [ {{#each locationHierarchyLevels}} { - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml b/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml index f0fc472eed7..93e0a90856c 100644 --- a/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml +++ b/automationtests/src/main/resources/masterdata/FetchModule/FetchModule.yml @@ -2,6 +2,7 @@ FetchModule: MasterData_FetchModule_allValid_smoke_with_lang: endPoint: /v1/masterdata/modules/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchModule/fetchModule outputTemplate: masterdata/FetchModule/fetchModuleResult @@ -9,9 +10,6 @@ FetchModule: "langcode": "eng" }' output: '{ -"modules": [{ - "langCode": "eng" - }] }' MasterData_FetchModule_Invalid_smoke_with_Invalid_langcode: endPoint: /v1/masterdata/modules/{langcode} diff --git a/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs b/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs index b100cd1694f..c1860fa3b57 100644 --- a/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchModule/fetchModuleResult.hbs @@ -1,12 +1,3 @@ { - "response": { - "modules": [ - {{#each modules}} - { - "langCode": "{{langCode}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } + } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs index 47bea2996bb..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentHolidayResult.hbs @@ -1,8 +1,2 @@ { -"response": { - "registrationCenter": - { - "langCode": "{{langCode}}" - } - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs index 9726e07e221..0e0dcd235c4 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentResult.hbs @@ -1,12 +1,3 @@ { -"response": { - "registrationCenters": [ - {{#each registrationCenters}} - { - "langCode": "{{langCode}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } + } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCentHistory/FetchRegCentHistory.yml b/automationtests/src/main/resources/masterdata/FetchRegCentHistory/FetchRegCentHistory.yml index 6d22873eab6..0dc5d15eabd 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCentHistory/FetchRegCentHistory.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCentHistory/FetchRegCentHistory.yml @@ -13,7 +13,6 @@ FetchRegCentHistory: }' output: '{ "registrationCentersHistory": [{ - "langCode": "$IGNORE$", "isActive": "true" }] }' diff --git a/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs index f9a765490c9..c2d60c7b5a5 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCentHistory/fetchRegCentHistoryResult.hbs @@ -3,7 +3,6 @@ "registrationCentersHistory": [ {{#each registrationCentersHistory}} { - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml index 0686db60f05..f8aa2b66eb9 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml +++ b/automationtests/src/main/resources/masterdata/FetchTemplate/FetchTemplate.yml @@ -41,7 +41,6 @@ FetchTemplate: }' output: '{ "templates": [{ - "langCode": "eng", "isActive": true }] }' diff --git a/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs b/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs index 5ace9e990f8..aabafa74d43 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTemplate/fetchTemplateResult.hbs @@ -3,7 +3,6 @@ "templates": [ {{#each templates}} { - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/FetchTitle/FetchTitle.yml b/automationtests/src/main/resources/masterdata/FetchTitle/FetchTitle.yml index 27fcfa30861..6eae40dc833 100644 --- a/automationtests/src/main/resources/masterdata/FetchTitle/FetchTitle.yml +++ b/automationtests/src/main/resources/masterdata/FetchTitle/FetchTitle.yml @@ -10,8 +10,7 @@ FetchTitle: }' output: '{ "titleList": [{ - "isActive": true, - "langCode": "eng" + "isActive": true }] }' MasterData_FetchTitle_valid_smoke: @@ -25,8 +24,7 @@ FetchTitle: }' output: '{ "titleList": [{ - "isActive": true, - "langCode": "eng" + "isActive": true }] }' MasterData_FetchTitle_invalid_langcode: diff --git a/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs b/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs index 5315a7502ce..5166baceb51 100644 --- a/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTitle/fetchTitleResult.hbs @@ -3,8 +3,7 @@ "titleList": [ {{#each titleList}} { - "isActive": {{isActive}}, - "langCode": "{{langCode}}" + "isActive": {{isActive}} } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml b/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml index 2ede1ec50f4..db7c2f58208 100644 --- a/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/FilterRegCenterType/FilterRegCenterType.yml @@ -61,7 +61,7 @@ FilterRegCenterType: "fieldCode": "$IGNORE$" }, { - "fieldID": "code", + "fieldID": "$IGNORE$", "fieldValue": "$IGNORE$", "fieldCode": "$IGNORE$" } diff --git a/automationtests/src/main/resources/masterdata/Gender/CreateGender.yml b/automationtests/src/main/resources/masterdata/Gender/CreateGender.yml index da5a0167546..eeaf8e2e5e4 100644 --- a/automationtests/src/main/resources/masterdata/Gender/CreateGender.yml +++ b/automationtests/src/main/resources/masterdata/Gender/CreateGender.yml @@ -14,8 +14,7 @@ CreateGender: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Genderdummy", - "langCode": "eng" + "code": "Genderdummy" }' Masterdata_CreateGender_Invalid_InputParameter_Code_Missing: endPoint: /v1/masterdata/gendertypes diff --git a/automationtests/src/main/resources/masterdata/Gender/UpdateGender.yml b/automationtests/src/main/resources/masterdata/Gender/UpdateGender.yml index 7852214659e..fdf9991d738 100644 --- a/automationtests/src/main/resources/masterdata/Gender/UpdateGender.yml +++ b/automationtests/src/main/resources/masterdata/Gender/UpdateGender.yml @@ -14,8 +14,7 @@ UpdateGender: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Genderdummy", - "langCode": "eng" + "code": "Genderdummy" }' Masterdata_UpdateGender_Invalid_InputParameter_Code_Missing: endPoint: /v1/masterdata/gendertypes diff --git a/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs b/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs +++ b/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/GetApplicationTypeByCodeAndLangcode.yml b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/GetApplicationTypeByCodeAndLangcode.yml index e12d2613e5b..1732e6772d5 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/GetApplicationTypeByCodeAndLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/GetApplicationTypeByCodeAndLangcode.yml @@ -11,8 +11,7 @@ GetApplicationTypeByCodeAndLangcode: "langCode":"eng" }' output: '{ - "code": "AAA", - "langCode": "eng" + "code": "AAA" }' Masterdata_GetApplicationTypeByCodeAndLangcode_InValid_Code: endPoint: /v1/masterdata/applicationtypes/{code}/{langCode} diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs index f4df188b204..9891875f850 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs @@ -2,8 +2,7 @@ "response": { "applicationtypes": [ { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } ] } diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypes/GetApplicationTypes.yml b/automationtests/src/main/resources/masterdata/GetApplicationTypes/GetApplicationTypes.yml index 08c68293a42..edfd45e8435 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypes/GetApplicationTypes.yml +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypes/GetApplicationTypes.yml @@ -2,6 +2,7 @@ GetApplicationTypes: Masterdata_GetApplicationTypes_allValid_smoke: endPoint: /v1/masterdata/applicationtypes role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetApplicationTypes/getApplicationTypes outputTemplate: masterdata/GetApplicationTypes/getApplicationTypesResult @@ -9,5 +10,4 @@ GetApplicationTypes: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/GetApplicationTypesByLangcode.yml b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/GetApplicationTypesByLangcode.yml index d14780137f6..03fa07e8fee 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/GetApplicationTypesByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/GetApplicationTypesByLangcode.yml @@ -2,6 +2,7 @@ GetApplicationTypesByLangcode: Masterdata_GetApplicationTypesByLangcode_allValid_smoke: endPoint: /v1/masterdata/applicationtypes/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcode @@ -10,13 +11,7 @@ GetApplicationTypesByLangcode: "langcode":"eng" }' output: '{ - "response":{ - "applicationtypes":[ - { - "langCode": "eng" - } - ] - } + }' Masterdata_GetApplicationTypesByLangcode_InValid_langCode: endPoint: /v1/masterdata/applicationtypes/{langcode} diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs index 1193b3b30cf..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs @@ -1,12 +1,2 @@ { - "response": { - "applicationtypes": [ - {{#each applicationtypes}} - { - "langCode": "{{langCode}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml index e8e18abe466..27619b02f28 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml +++ b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/GetBiometricAttributesByAuthType.yml @@ -15,7 +15,6 @@ GetBiometricAttributesByAuthType: "name": "$IGNORE$", "description": "$IGNORE$", "biometricTypeCode": "FNR", - "langCode": "eng", "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs index d07033101a9..20a3dbc6d64 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs @@ -4,8 +4,7 @@ {{#each biometricattributes}} { - "biometricTypeCode": "{{biometricTypeCode}}", - "langCode": "{{langCode}}" + "biometricTypeCode": "{{biometricTypeCode}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/GetBiometricTypeByCodeAndLangcode.yml b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/GetBiometricTypeByCodeAndLangcode.yml index b88a8824cbd..b22fb5c14ee 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/GetBiometricTypeByCodeAndLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/GetBiometricTypeByCodeAndLangcode.yml @@ -11,8 +11,7 @@ GetBiometricTypeByCodeAndLangcode: "langCode":"eng" }' output: '{ - "code": "FNR", - "langCode": "eng" + "code": "FNR" }' Masterdata_GetBiometricTypeByCodeAndLangcode_allValid_IRS_smoke: endPoint: /v1/masterdata/biometrictypes/{code}/{langCode} @@ -26,8 +25,7 @@ GetBiometricTypeByCodeAndLangcode: "langCode":"eng" }' output: '{ - "code": "IRS", - "langCode": "eng" + "code": "IRS" }' Masterdata_GetBiometricTypeByCodeAndLangcode_allValid_PHT_smoke: endPoint: /v1/masterdata/biometrictypes/{code}/{langCode} @@ -41,8 +39,7 @@ GetBiometricTypeByCodeAndLangcode: "langCode":"eng" }' output: '{ - "code": "PHT", - "langCode": "eng" + "code": "PHT" }' Masterdata_GetBiometricTypeByCodeAndLangcode_InValid_Code: endPoint: /v1/masterdata/biometrictypes/{code}/{langCode} diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs index fa0b3081a3b..bf5607e4fbc 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs @@ -2,8 +2,7 @@ "response": { "biometrictypes": [ { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } ] } diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml index a9b05937973..966645e8cbf 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/GetBiometricTypesByLangcode.yml @@ -11,13 +11,7 @@ GetBiometricTypesByLangcode: "langcode":"eng" }' output: '{ - "response":{ - "biometrictypes":[ - { - "langCode": "eng" - } - ] - } + }' Masterdata_GetBiometricTypesByLangcode_InValid_langCode: endPoint: /v1/masterdata/biometrictypes/{langcode} diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs index 66b31622eb2..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs @@ -1,12 +1,2 @@ { - "response": { - "biometrictypes": [ - {{#each biometrictypes}} - { - "langCode": "{{langCode}}" - } - {{#unless @last}},{{/unless}} - {{/each}} - ] - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDeviceHistory/GetDeviceHistory.yml b/automationtests/src/main/resources/masterdata/GetDeviceHistory/GetDeviceHistory.yml index 3323e458e27..aa73899a39e 100644 --- a/automationtests/src/main/resources/masterdata/GetDeviceHistory/GetDeviceHistory.yml +++ b/automationtests/src/main/resources/masterdata/GetDeviceHistory/GetDeviceHistory.yml @@ -13,7 +13,6 @@ GetDeviceHistory: }' output: '{ "deviceHistoryDetails": [{ - "langCode": "$IGNORE$", "isActive": true }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs b/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs index ca289e5b43b..e46d49ed1b9 100644 --- a/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDeviceHistory/getDeviceHistoryResult.hbs @@ -3,7 +3,6 @@ "deviceHistoryDetails": [ {{#each deviceHistoryDetails}} { - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs index 6361e47cf28..86e2c2db9c0 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs @@ -7,7 +7,6 @@ "code": "{{code}}", "name": "{{name}}", "description": "{{description}}", - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs index 6361e47cf28..86e2c2db9c0 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs @@ -7,7 +7,6 @@ "code": "{{code}}", "name": "{{name}}", "description": "{{description}}", - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/GetDocType_DocCatByAppID.yml b/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/GetDocType_DocCatByAppID.yml index eaf2d7ea17d..7e6506d19de 100644 --- a/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/GetDocType_DocCatByAppID.yml +++ b/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/GetDocType_DocCatByAppID.yml @@ -10,11 +10,9 @@ GetDocType_DocCatByAppID: "languages": "eng" }' output: '{ - "langCode":"eng", "isActive":true, "documentCategories":[ { - "langCode":"eng", "isActive":true }] }' diff --git a/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs b/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs index a6ccd71b634..50d5aa48248 100644 --- a/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocType_DocCatByAppID/getDocType_DocCatByAppIDResult.hbs @@ -1,11 +1,9 @@ { "response":{ - "langCode":"{{langCode}}", "isActive":{{isActive}}, "documentCategories":[ {{#each documentCategories}} { - "langCode":"{{langCode}}", "isActive":{{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml index 7b2f4207bba..2e01bdb3e33 100644 --- a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/GetDocumentTypeByLangCode.yml @@ -14,7 +14,6 @@ GetDocumentTypeByLangCode: "code": "$IGNORE$", "name": "$IGNORE$", "description": "$IGNORE$", - "langCode": "eng", "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs index e3b48b3292e..e40c0317042 100644 --- a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs @@ -7,7 +7,6 @@ "code": "{{code}}", "name": "{{name}}", "description": "{{description}}", - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml index 4423ef4cf4c..15f59c719c9 100644 --- a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/GetIdTypeByLangCode.yml @@ -14,7 +14,6 @@ GetIdTypeByLangCode: "code": "$IGNORE$", "descr": "$IGNORE$", "name": "$IGNORE$", - "langCode": "eng", "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs index 5343ad31236..1a097d0ccfc 100644 --- a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs @@ -7,7 +7,6 @@ "code": "{{code}}", "descr": "{{descr}}", "name": "{{name}}", - "langCode": "{{langCode}}", "isActive": {{isActive}} } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/GetLeafZonesByLangCode.yml b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/GetLeafZonesByLangCode.yml index da334dbb16e..7a9ccadb6af 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/GetLeafZonesByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/GetLeafZonesByLangCode.yml @@ -2,6 +2,7 @@ GetLeafZonesByLangCode: MasterData_GetLeafZonesByLangCode_allValid_smoke: endPoint: /v1/masterdata/zones/leafzones/{langCode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCode outputTemplate: masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult @@ -9,7 +10,6 @@ GetLeafZonesByLangCode: "langCode": "eng" }' output: '{ - "langCode": "eng" }' MasterData_GetLeafZonesByLangCode_inValid_code: endPoint: /v1/masterdata/zones/leafzones/{langCode} diff --git a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs index f4a42f02345..077404aaa41 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs @@ -1,6 +1,3 @@ { - "response": { - "langCode": "{{langCode}}" - }, - "errors": $IGNORE$ + } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/GetLeafsByLangCode.yml b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/GetLeafsByLangCode.yml index 1a1e52d1381..210d76dc295 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/GetLeafsByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/GetLeafsByLangCode.yml @@ -2,6 +2,7 @@ GetLeafsByLangCode: MasterData_GetLeafsByLangCode_allValid_smoke: endPoint: /v1/masterdata/zones/leafs/{langCode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetLeafsByLangCode/getLeafsByLangCode outputTemplate: masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult @@ -9,7 +10,6 @@ GetLeafsByLangCode: "langCode": "eng" }' output: '{ - "langCode": "eng" }' MasterData_GetLeafsByLangCode_inValid_code: endPoint: /v1/masterdata/zones/leafs/{langCode} diff --git a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs index a9c07c57aa6..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "langCode": "{{langCode}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml index b440ed60f57..defb1fb5491 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/GetLocationHierarchyByHierarchyName.yml @@ -15,7 +15,6 @@ GetLocationHierarchyByHierarchyName: "hierarchyLevel": "$IGNORE$", "hierarchyName": "City", "parentLocCode": "$IGNORE$", - "langCode": "$IGNORE$", "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs index 1f91105fe9c..713f0b0dfd7 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs @@ -9,7 +9,6 @@ "hierarchyLevel": "{{hierarchyLevel}}", "hierarchyName": "{{hierarchyName}}", "parentLocCode": "{{parentLocCode}}", - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs index 996b9470269..c11817454b6 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs @@ -6,7 +6,6 @@ { "hierarchyLevel": "{{hierarchyLevel}}", "hierarchyLevelName": "{{hierarchyLevelName}}", - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetMachineHistory/GetMachineHistory.yml b/automationtests/src/main/resources/masterdata/GetMachineHistory/GetMachineHistory.yml index 51f55948435..2c1266c0d02 100644 --- a/automationtests/src/main/resources/masterdata/GetMachineHistory/GetMachineHistory.yml +++ b/automationtests/src/main/resources/masterdata/GetMachineHistory/GetMachineHistory.yml @@ -14,7 +14,7 @@ GetMachineHistory: "machineHistoryDetails": [{ "id": "10001", "name": "$IGNORE$", - "langCode": "eng", + "langCode": "$IGNORE$", "isActive": true, "serialNum": "$IGNORE$", "ipAddress": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs b/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs index 87e3633d417..58c518809cf 100644 --- a/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs @@ -6,7 +6,6 @@ { "id": "{{id}}", "name": "{{name}}", - "langCode": "{{langCode}}", "isActive": {{isActive}}, "serialNum": "{{serialNum}}", "ipAddress": "{{ipAddress}}", diff --git a/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs b/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs index 3ad56e71f73..9b6efedf4ac 100644 --- a/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs @@ -11,7 +11,6 @@ "ipAddress": "{{ipAddress}}", "machineSpecId": "{{machineSpecId}}", "regCenterId": "{{regCenterId}}", - "langCode": "{{langCode}}", "isActive": {{isActive}}, "validityDateTime": "{{validityDateTime}}", "publicKey":"{{publicKey}}", diff --git a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/GetSubZoneByLangCode.yml b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/GetSubZoneByLangCode.yml index c85f6f3272f..889b19af9cf 100644 --- a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/GetSubZoneByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/GetSubZoneByLangCode.yml @@ -9,7 +9,6 @@ GetSubZoneByLangCode: "langCode": "eng" }' output: '{ - "langCode": "eng" }' MasterData_GetSubZoneByLangCode_inValid_code: endPoint: /v1/masterdata/zones/subzone/{langCode} diff --git a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs index a9c07c57aa6..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs @@ -1,5 +1,2 @@ { - "response": { - "langCode": "{{langCode}}" - } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs index 46f1d85ef10..2b0d1393231 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs @@ -12,7 +12,6 @@ "moduleId": "{{moduleId}}", "moduleName": "ID Authentication", "templateTypeCode": "{{templateTypeCode}}", - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml b/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml index 7b33e161cae..72fa466199a 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/GetUserDetails.yml @@ -9,7 +9,6 @@ GetUserDetails: "id":"$REMOVE$" }' output: '{ - "langCode": "eng", "name": "$IGNORE$", "statusCode": "$IGNORE$", "regCenterId": "10005", @@ -26,7 +25,6 @@ GetUserDetails: "id":"func_auto_test_user" }' output: '{ - "langCode": "eng", "name": "$IGNORE$", "statusCode": "$IGNORE$", "regCenterId": "10005", diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs index 4ded4bbf36c..fd425050d41 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs @@ -1,6 +1,5 @@ { "response": { - "langCode": "{{langCode}}", "regCenterId": "{{regCenterId}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs index f1c38ebe483..23b0c25200f 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs @@ -5,7 +5,6 @@ "metadata": "$IGNORE$", "response": { "id": "{{id}}", - "langCode": "{{langCode}}", "name": "$IGNORE$", "statusCode": "$IGNORE$", "regCenterId": "{{regCenterId}}", diff --git a/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/GetUserDetailsByIdAndEffDate.yml b/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/GetUserDetailsByIdAndEffDate.yml index c4c7716c623..3efac361a13 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/GetUserDetailsByIdAndEffDate.yml +++ b/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/GetUserDetailsByIdAndEffDate.yml @@ -11,8 +11,7 @@ GetUserDetailsByIdAndEffDate: "effDate":"2023-12-10T08:43:46.614Z" }' output: '{ - "id": "func_auto_test_user", - "langCode": "eng" + "id": "func_auto_test_user" }' MasterData_GetUserDetailsByIdAndEffDate_InValid_dateFormat: endPoint: /v1/masterdata/users/{id}/{effDate} diff --git a/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs index 5fb13c4cc7f..c68f402cf7d 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetailsByIdAndEffDate/getUserDetailsByIdAndEffDateResult.hbs @@ -1,8 +1,7 @@ { "response": { "userResponseDto": [{ - "id": "{{id}}", - "langCode": "{{langCode}}" + "id": "{{id}}" }] } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml b/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml index 4d4b64653b2..a317f255b09 100644 --- a/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml +++ b/automationtests/src/main/resources/masterdata/GetValidDocument/GetValidDocument.yml @@ -2,6 +2,7 @@ GetValidDocument: MasterData_GetValidDocument_allValid_smoke: endPoint: /v1/masterdata/validdocuments/{docCategoryCode}/{langCode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetValidDocument/getValidDocument outputTemplate: masterdata/GetValidDocument/getValidDocumentResult @@ -14,7 +15,6 @@ GetValidDocument: "docTypeCode": "$IGNORE$", "docCategoryCode": "$IGNORE$", "docTypeName": "$IGNORE$", - "langCode": "eng", "isActive": "$IGNORE$" }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs b/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs index 792b4193c24..7a73a41bfdf 100644 --- a/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs @@ -1,5 +1,2 @@ { - "response": [{ - "langCode": "eng" - }] } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetWeekDay/GetWeekDay.yml b/automationtests/src/main/resources/masterdata/GetWeekDay/GetWeekDay.yml index 1ad752b62b9..73add56ebd7 100644 --- a/automationtests/src/main/resources/masterdata/GetWeekDay/GetWeekDay.yml +++ b/automationtests/src/main/resources/masterdata/GetWeekDay/GetWeekDay.yml @@ -11,7 +11,7 @@ GetWeekDay: }' output: '{ "weekdays": [{ - "languageCode": "eng" + "languageCode": "$IGNORE$" }] }' MasterData_GetWeekDay_InValid_InvalidLangCode: diff --git a/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/GetZoneHierarchyByLangCode.yml b/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/GetZoneHierarchyByLangCode.yml index e16343bcf35..ce482f6c504 100644 --- a/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/GetZoneHierarchyByLangCode.yml +++ b/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/GetZoneHierarchyByLangCode.yml @@ -9,7 +9,7 @@ GetZoneHierarchyByLangCode: "langCode": "eng" }' output: '{ - "langCode": "eng" + "langCode": "$IGNORE$" }' MasterData_GetZoneHierarchyByLangCode_inValid_code: endPoint: /v1/masterdata/zones/hierarchy/{langCode} diff --git a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml index 88e6178c550..c910e901f1f 100644 --- a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml +++ b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/GetimmediateChildrenByLocationCode.yml @@ -2,6 +2,7 @@ GetimmediateChildrenByLocationCode: Admin_GetimmediateChildrenByLocationCode_allValid_smoke: endPoint: /v1/masterdata/locations/immediatechildren/{locationcode}/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCode outputTemplate: masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult @@ -16,7 +17,6 @@ GetimmediateChildrenByLocationCode: "hierarchyLevel": "$IGNORE$", "hierarchyName": "$IGNORE$", "parentLocCode": "$IGNORE$", - "langCode": "eng", "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs index 1f91105fe9c..713f0b0dfd7 100644 --- a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs @@ -9,7 +9,6 @@ "hierarchyLevel": "{{hierarchyLevel}}", "hierarchyName": "{{hierarchyName}}", "parentLocCode": "{{parentLocCode}}", - "langCode": "{{langCode}}", "isActive": "{{isActive}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml b/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml index 17348f93564..701a5b1d7ea 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml +++ b/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml @@ -20,7 +20,7 @@ CreateHoliday: "locationCode": "$IGNORE$", "holidayDate": "2020-08-15", "holidayName": "AutoTest user Eng", - "langCode": "eng" + "langCode": "$IGNORE$" }' MasterData_CreateHoliday_Invalid_InputParameter_HolidayDate_Missing: endPoint: /v1/masterdata/holidays diff --git a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml index 58baf038480..8d7bf303cf1 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml +++ b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml @@ -21,7 +21,7 @@ UpdateHoliday: "locationCode": "$IGNORE$", "holidayDate": "2020-08-15", "holidayName": "AutoTest user", - "langCode": "eng" + "langCode": "$IGNORE$" }' MasterData_UpdateHoliday_Invalid_InputParameter_HolidayDate_Missing: endPoint: /v1/masterdata/holidays diff --git a/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs b/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs index a6b225cac76..a683446b40f 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs @@ -2,7 +2,6 @@ "response": { "locationCode": "{{locationCode}}", "holidayDate": "{{holidayDate}}", - "holidayName": "{{holidayName}}", - "langCode": "{{langCode}}" + "holidayName": "{{holidayName}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml b/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml index 0e15a053988..cd0a45f9f4f 100644 --- a/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml +++ b/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml @@ -28,9 +28,8 @@ CreateMachine: "serialNum": "FB5962911687", "ipAddress": "192.168.0.424", "isActive": "$IGNORE$", - "langCode": "eng", "macAddress": "61-D3-FD-12-C9-ED", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "validityDateTime": "$IGNORE$" }' Masterdata_CreateMachine_Invalid_publicKey: diff --git a/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml b/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml index 66901fbb7ff..87484a0be6e 100644 --- a/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml +++ b/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml @@ -30,7 +30,7 @@ UpdateMachine: "isActive": "$IGNORE$", "langCode": "$IGNORE$", "macAddress": "61-D3-FD-12-C9-ED", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "validityDateTime": "$IGNORE$" }' Masterdata_UpdateMachine_Invalid_validitydate_Format: diff --git a/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs b/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs index c3475f33110..4bd48bc38a3 100644 --- a/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs +++ b/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs @@ -6,7 +6,6 @@ "machineSpecId":"{{machineSpecId}}", "macAddress":"{{macAddress}}", "ipAddress":"{{ipAddress}}", -"langCode":"{{langCode}}", "validityDateTime":"{{validityDateTime}}", "isActive":"{{isActive}}" } diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml b/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml index 0a75e432713..41b9163b29f 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/CreateMachineSpecification.yml @@ -2,6 +2,7 @@ CreateMachineSpecification: Masterdata_CreateMachineSpecification_All_Valid_Smoke_sid: endPoint: /v1/masterdata/machinespecifications role: admin + checkErrorsOnlyInResponse: true templateFields: ["description"] restMethod: post inputTemplate: masterdata/MachineSpecification/machineSpecification @@ -19,8 +20,7 @@ CreateMachineSpecification: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$", - "langCode": "eng" + "id": "$IGNORE$" }' Masterdata_CreateMachineSpecification_InputParameter_Name_Missing: endPoint: /v1/masterdata/machinespecifications diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs index 9be53d201f0..b8eed36f548 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs @@ -1,6 +1,5 @@ { "response": { - "id": "{{id}}", - "langCode": "{{langCode}}" + "id": "{{id}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/UpdateMachineSpecification.yml b/automationtests/src/main/resources/masterdata/MachineSpecification/UpdateMachineSpecification.yml index 61cf020e728..aa0e4e785ab 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/UpdateMachineSpecification.yml +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/UpdateMachineSpecification.yml @@ -2,6 +2,7 @@ UpdateMachineSpecification: Masterdata_UpdateMachineSpecification_All_Valid_Smoke: endPoint: /v1/masterdata/machinespecifications role: admin + checkErrorsOnlyInResponse: true templateFields: ["description"] restMethod: put inputTemplate: masterdata/MachineSpecification/machineSpecification @@ -19,8 +20,7 @@ UpdateMachineSpecification: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$", - "langCode": "eng" + "id": "$IGNORE$" }' Masterdata_UpdateMachineSpecification_InputParameter_Name_Missing: endPoint: /v1/masterdata/machinespecifications diff --git a/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml b/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml index 290dd38c154..03a05de66c6 100644 --- a/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml +++ b/automationtests/src/main/resources/masterdata/MachineType/CreateMachineType.yml @@ -15,8 +15,7 @@ CreateMachineType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Laptop2", - "langCode": "eng" + "code": "Laptop2" }' Masterdata_CreateMachineType_Invalid_InputParameter_Code_Missing: endPoint: /v1/masterdata/machinetypes diff --git a/automationtests/src/main/resources/masterdata/MachineType/UpdateMachineType.yml b/automationtests/src/main/resources/masterdata/MachineType/UpdateMachineType.yml index f56fa492f5a..abc40355fe1 100644 --- a/automationtests/src/main/resources/masterdata/MachineType/UpdateMachineType.yml +++ b/automationtests/src/main/resources/masterdata/MachineType/UpdateMachineType.yml @@ -15,8 +15,7 @@ UpdateMachineType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Laptop2", - "langCode": "eng" + "code": "Laptop2" }' Masterdata_UpdateMachineType_Invalid_InputParameter_Code_Missing: endPoint: /v1/masterdata/machinetypes diff --git a/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs b/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml b/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml index ea104bb4cc5..8b3ec65fe59 100644 --- a/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml +++ b/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml @@ -33,7 +33,6 @@ MachineTypeSearch: "isActive": "$IGNORE$", "createdBy": "$IGNORE$", "code": "Laptop-2", - "langCode": "eng", "name": "$IGNORE$", "description": "$IGNORE$" } diff --git a/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs b/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs index 2e609f360a2..153bad660de 100644 --- a/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs @@ -6,7 +6,6 @@ "isActive": "{{isActive}}", "createdBy": "{{createdBy}}", "code": "{{code}}", - "langCode": "{{langCode}}", "name": "{{name}}", "description": "{{description}}" } diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/PacketRejectionReasonCategory.yml b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/PacketRejectionReasonCategory.yml index 16ac31ea2c6..85ef6e56cc6 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/PacketRejectionReasonCategory.yml +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/PacketRejectionReasonCategory.yml @@ -15,8 +15,7 @@ PacketRejectionReasonCategory: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "TEST_CAT_CODE", - "langCode": "eng" + "code": "TEST_CAT_CODE" }' MasterData_PacketRejectionReasonCategory_Invalid_langCode: diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs index 8992fbe1aa7..a2a520889b3 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/PacketRejectionReasonList.yml b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/PacketRejectionReasonList.yml index a6a2ba1d608..c16918c8675 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/PacketRejectionReasonList.yml +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/PacketRejectionReasonList.yml @@ -17,8 +17,7 @@ PacketRejectionReasonList: }' output: '{ "rsnCatCode": "TEST_CAT_CODE", - "code": "TEST_LIST_CODE", - "langCode": "eng" + "code": "TEST_LIST_CODE" }' MasterData_PacketRejectionReasonList_Invalid_Invalid_langCode: diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs index 02e49d009ae..83398b1a32c 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs @@ -1,7 +1,6 @@ { "response": { "rsnCatCode": "{{rsnCatCode}}", - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterSearch/RegCenterSearch.yml b/automationtests/src/main/resources/masterdata/RegCenterSearch/RegCenterSearch.yml index 3f48c0d173a..34ff8dd013d 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterSearch/RegCenterSearch.yml +++ b/automationtests/src/main/resources/masterdata/RegCenterSearch/RegCenterSearch.yml @@ -29,7 +29,6 @@ RegCenterSearch: }' output: '{ "data": [{ - "name": "Center Mehdia", - "langCode": "eng" + "name": "Center Mehdia" }] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs index d178b3252a5..c33d4d45610 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs @@ -3,8 +3,7 @@ "data": [ {{#each data}} { - "name": "{{name}}", - "langCode": "{{langCode}}" + "name": "{{name}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml b/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml index 8f3173b95eb..ff81723f0ad 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml @@ -15,8 +15,7 @@ UpdateRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "ALT-3", - "langCode": "eng" + "code": "ALT-3" }' MasterData_UpdateRegCenterType_InputParameter_Name_Missing: @@ -128,6 +127,5 @@ UpdateRegCenterType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "ALT-3", - "langCode": "eng" + "code": "ALT-3" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RejectionList/RejectionList.yml b/automationtests/src/main/resources/masterdata/RejectionList/RejectionList.yml index 5583c8ea6c0..f9b8c64d758 100644 --- a/automationtests/src/main/resources/masterdata/RejectionList/RejectionList.yml +++ b/automationtests/src/main/resources/masterdata/RejectionList/RejectionList.yml @@ -18,6 +18,5 @@ RejectionList: output: '{ "rsnCatCode": "CLR", "code": "ABC", - "langCode": "eng", "requesttime": "$TIMESTAMP$" }' diff --git a/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs b/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs index 0b6622e68bd..69276176e5d 100644 --- a/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs +++ b/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs @@ -1,7 +1,6 @@ { "response":{ "rsnCatCode": "{{rsnCatCode}}", -"code": "{{code}}", -"langCode": "{{langCode}}" +"code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml index 41968337461..7aaa68b6089 100644 --- a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/SearchBlockListedWords.yml @@ -32,8 +32,7 @@ SearchBlockListedWords: { "isActive": "$IGNORE$", "description": "$IGNORE$", - "word": "dumbo7", - "langCode": "eng" + "word": "dumbo7" } ] }' @@ -70,8 +69,7 @@ SearchBlockListedWords: { "isActive": "$IGNORE$", "description": "$IGNORE$", - "word": "dumbo7", - "langCode": "eng" + "word": "dumbo7" } ] }' @@ -108,8 +106,7 @@ SearchBlockListedWords: { "isActive": "$IGNORE$", "description": "$IGNORE$", - "word": "dumbo7", - "langCode": "eng" + "word": "dumbo7" } ] }' @@ -182,8 +179,7 @@ SearchBlockListedWords: { "isActive": "$IGNORE$", "description": "$IGNORE$", - "word": "dumb7", - "langCode": "eng" + "word": "dumb7" } ] }' diff --git a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs index a2d1d6b36f9..ea1c676f225 100644 --- a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs @@ -5,7 +5,6 @@ { "isActive": "{{isActive}}", "word": "{{word}}", - "langCode": "{{langCode}}", "description": "{{description}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml b/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml index 4fa7c7e1e99..d6bb70f0cbd 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml +++ b/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml @@ -32,7 +32,6 @@ SearchDocCategories: ], "pageStart": 0, "pageFetch": 1, - "languageCode": "eng", "requesttime": "$TIMESTAMP$" }' output: '{ diff --git a/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs b/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs index b3375ab0b23..b692d03d39b 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs @@ -6,7 +6,6 @@ "isActive": "{{isActive}}", "code": "{{code}}", "name": "{{name}}", - "langCode": "{{langCode}}", "description": "{{description}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs index b3375ab0b23..b692d03d39b 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs @@ -6,7 +6,6 @@ "isActive": "{{isActive}}", "code": "{{code}}", "name": "{{name}}", - "langCode": "{{langCode}}", "description": "{{description}}" } {{#unless @last}},{{/unless}} diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml index e8dbfcbdd8d..b0beb7814c0 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml @@ -129,8 +129,7 @@ SearchMachine: "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } @@ -173,8 +172,7 @@ SearchMachine: "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } @@ -217,8 +215,7 @@ SearchMachine: "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } @@ -520,8 +517,7 @@ SearchMachine: "macAddress": "61-D3-FD-12-C9-ED", "ipAddress": "192.168.0.424", "machineSpecId": "$IGNORE$", - "langCode": "$IGNORE$", - "zoneCode": "$ZONE_CODE$", + "zoneCode": "$IGNORE$", "zone": "$IGNORE$", "isActive": "$IGNORE$" } diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs index 4a030d6e0b3..c1ce7a68cb9 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs @@ -9,7 +9,6 @@ "macAddress": "{{macAddress}}", "ipAddress": "{{ipAddress}}", "machineSpecId": "{{machineSpecId}}", - "langCode": "{{langCode}}", "zoneCode": "{{zoneCode}}", "zone": "{{zone}}", "isActive": "{{isActive}}" diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml index ce61d7b2469..6fa11e5a770 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml @@ -36,7 +36,6 @@ SearchMachineSpec: "machineTypeCode": "$IGNORE$", "minDriverversion": "3.2", "description": "HP brand", - "langCode": "eng", "isActive": "$IGNORE$" }] }' @@ -75,7 +74,6 @@ SearchMachineSpec: "machineTypeCode": "$IGNORE$", "minDriverversion": "3.2", "description": "HP brand", - "langCode": "eng", "isActive": "$IGNORE$" }] }' @@ -114,7 +112,6 @@ SearchMachineSpec: "machineTypeCode": "$IGNORE$", "minDriverversion": "3.2", "description": "HP brand", - "langCode": "eng", "isActive": "$IGNORE$" }] }' @@ -153,7 +150,6 @@ SearchMachineSpec: "machineTypeCode": "$IGNORE$", "minDriverversion": "3.2", "description": "HP brand", - "langCode": "eng", "isActive": "$IGNORE$" }] }' @@ -221,7 +217,6 @@ SearchMachineSpec: "machineTypeCode": "$IGNORE$", "minDriverversion": "3.2", "description": "HP brand", - "langCode": "eng", "isActive": "$IGNORE$" }] }' @@ -260,7 +255,6 @@ SearchMachineSpec: "machineTypeCode": "$IGNORE$", "minDriverversion": "3.2", "description": "HP brand", - "langCode": "eng", "isActive": "$IGNORE$" }] }' diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs index 47b22cd1d4c..d9d83145e64 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs @@ -5,7 +5,6 @@ { "isActive": "{{isActive}}", "id": "{{id}}", - "langCode": "{{langCode}}", "name": "{{name}}", "description": "{{description}}", "model": "{{model}}", diff --git a/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml b/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml index 0781fdc6362..0764fa2e647 100644 --- a/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml +++ b/automationtests/src/main/resources/masterdata/SearchZoneUser/SearchZoneUser.yml @@ -34,7 +34,6 @@ SearchZoneUser: "deletedDateTime": "$IGNORE$", "zoneCode": "$IGNORE$", "userId": "$IGNORE$", - "langCode": "eng", "userName": "$IGNORE$", "zoneName": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs b/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs index 8d6eb1354fc..098c136abdc 100644 --- a/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs @@ -5,7 +5,6 @@ { "zoneCode": "{{zoneCode}}", "userId": "{{userId}}", - "langCode": "{{langCode}}", "userName": "{{userName}}", "zoneName": "{{zoneName}}" } diff --git a/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml b/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml index c2a02ba6c07..ccfebd5c293 100644 --- a/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml +++ b/automationtests/src/main/resources/masterdata/Template/CreateTemplate.yml @@ -22,8 +22,7 @@ CreateTemplate: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$", - "langCode": "$IGNORE$" + "id": "$IGNORE$" }' MasterData_CreateTemplate_InputParameter_Name_Missing: endPoint: /v1/masterdata/templates diff --git a/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml b/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml index b8ff20db18e..5f50d929b76 100644 --- a/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml +++ b/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml @@ -21,8 +21,7 @@ UpdateTemplate: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$", - "langCode": "$IGNORE$" + "id": "$IGNORE$" }' MasterData_UpdateTemplate_InputParameter_Name_Missing: endPoint: /v1/masterdata/templates diff --git a/automationtests/src/main/resources/masterdata/Template/templateResult.hbs b/automationtests/src/main/resources/masterdata/Template/templateResult.hbs index 9be53d201f0..b8eed36f548 100644 --- a/automationtests/src/main/resources/masterdata/Template/templateResult.hbs +++ b/automationtests/src/main/resources/masterdata/Template/templateResult.hbs @@ -1,6 +1,5 @@ { "response": { - "id": "{{id}}", - "langCode": "{{langCode}}" + "id": "{{id}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TemplateFileFormat/CreateTemplateFileFormat.yml b/automationtests/src/main/resources/masterdata/TemplateFileFormat/CreateTemplateFileFormat.yml index f4236866e84..3072bde1481 100644 --- a/automationtests/src/main/resources/masterdata/TemplateFileFormat/CreateTemplateFileFormat.yml +++ b/automationtests/src/main/resources/masterdata/TemplateFileFormat/CreateTemplateFileFormat.yml @@ -14,8 +14,7 @@ CreateTemplateFileFormat: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Doc", - "langCode": "eng" + "code": "Doc" }' Masterdata_CreateTemplateFileFormat_InputParameter_Description_AboveMaxLen256: endPoint: /v1/masterdata/templatefileformats diff --git a/automationtests/src/main/resources/masterdata/TemplateFileFormat/UpdateTemplateFileFormat.yml b/automationtests/src/main/resources/masterdata/TemplateFileFormat/UpdateTemplateFileFormat.yml index e5f3e44dc63..5773ba5e42d 100644 --- a/automationtests/src/main/resources/masterdata/TemplateFileFormat/UpdateTemplateFileFormat.yml +++ b/automationtests/src/main/resources/masterdata/TemplateFileFormat/UpdateTemplateFileFormat.yml @@ -14,8 +14,7 @@ UpdateTemplateFileFormat: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Doc", - "langCode": "eng" + "code": "Doc" }' Masterdata_UpdateTemplateFileFormat_InputParameter_Description_AboveMaxLen256: endPoint: /v1/masterdata/templatefileformats diff --git a/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TemplateType/CreateTemplateType.yml b/automationtests/src/main/resources/masterdata/TemplateType/CreateTemplateType.yml index 22878f955db..13e816fcb5b 100644 --- a/automationtests/src/main/resources/masterdata/TemplateType/CreateTemplateType.yml +++ b/automationtests/src/main/resources/masterdata/TemplateType/CreateTemplateType.yml @@ -14,8 +14,7 @@ CreateTemplateType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "Test-info-Template-auto", - "langCode": "eng" + "code": "Test-info-Template-auto" }' diff --git a/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Title/CreateTitle.yml b/automationtests/src/main/resources/masterdata/Title/CreateTitle.yml index bd632257918..b22e89b6715 100644 --- a/automationtests/src/main/resources/masterdata/Title/CreateTitle.yml +++ b/automationtests/src/main/resources/masterdata/Title/CreateTitle.yml @@ -15,8 +15,7 @@ CreateTitle: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "TEST0011", - "langCode": "eng" + "code": "TEST0011" }' diff --git a/automationtests/src/main/resources/masterdata/Title/UpdateTitle.yml b/automationtests/src/main/resources/masterdata/Title/UpdateTitle.yml index 95a2ce8904a..29107d16399 100644 --- a/automationtests/src/main/resources/masterdata/Title/UpdateTitle.yml +++ b/automationtests/src/main/resources/masterdata/Title/UpdateTitle.yml @@ -15,8 +15,7 @@ UpdateTitle: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "TEST0011", - "langCode": "eng" + "code": "TEST0011" }' MasterData_UpdateTitle_Invalid_InputParameter_TitleName_Missing: diff --git a/automationtests/src/main/resources/masterdata/Title/titleResult.hbs b/automationtests/src/main/resources/masterdata/Title/titleResult.hbs index 1c6a42c563e..746766497bc 100644 --- a/automationtests/src/main/resources/masterdata/Title/titleResult.hbs +++ b/automationtests/src/main/resources/masterdata/Title/titleResult.hbs @@ -1,6 +1,5 @@ { "response": { - "code": "{{code}}", - "langCode": "{{langCode}}" + "code": "{{code}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml b/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml index ef888197b48..f91baa134c0 100644 --- a/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml +++ b/automationtests/src/main/resources/masterdata/TitleSearch/TitleSearch.yml @@ -85,8 +85,7 @@ TitleSearch: { "code": "TEST0011", "titleName": "TEST0011", - "titleDescription": "TEST0011", - "langCode": "eng" + "titleDescription": "TEST0011" } ] }' @@ -121,8 +120,7 @@ TitleSearch: { "code": "TEST0011", "titleName": "TEST0011", - "titleDescription": "$IGNORE$", - "langCode": "ara" + "titleDescription": "$IGNORE$" } ] }' @@ -459,8 +457,7 @@ TitleSearch: { "code": "TEST0011", "titleName": "TEST0011", - "titleDescription": "TEST0011", - "langCode": "eng" + "titleDescription": "TEST0011" } ] }' @@ -495,8 +492,7 @@ TitleSearch: { "code": "TEST0011", "titleName": "TEST0011", - "titleDescription": "TEST0011", - "langCode": "eng" + "titleDescription": "TEST0011" } ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs b/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs index e229a753296..4f9a25c05c4 100644 --- a/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs @@ -6,8 +6,7 @@ "isActive": "{{isActive}}", "code": "{{code}}", "titleName": "{{titleName}}", - "titleDescription": "{{titleDescription}}", - "langCode": "{{langCode}}" + "titleDescription": "{{titleDescription}}" } {{#unless @last}},{{/unless}} {{/each}} diff --git a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml index d9dcfcfd99c..a6385212d65 100644 --- a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml +++ b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml @@ -14,8 +14,7 @@ UpdateBlockListedWordDetails: "requesttime": "$TIMESTAMP$" }' output: '{ - "word": "dumbooo", - "langCode": "eng" + "word": "dumbooo" }' Masterdata_CreateBlockListedWords_Invalid_BlocklistedWordsLength129: endPoint: /v1/masterdata/blocklistedwords/details diff --git a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs index e0205766751..660bddf4626 100644 --- a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs @@ -1,6 +1,5 @@ { "response":{ -"word":"{{word}}", -"langCode":"{{langCode}}" +"word":"{{word}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml index dc7a20f74fe..68dd625048e 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/UpdateRegistrationCenterLang.yml @@ -22,7 +22,6 @@ UpdateRegistrationCenterLang: "addressLine1": "National Road Test", "addressLine2": "Alla Tazi Test", "addressLine3": "MyCountry Test", - "langCode": "eng", "contactPerson": "Cliff Hanger Test" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs index a0bbe3e300a..189dfa09f6c 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs @@ -5,7 +5,6 @@ "addressLine1": "{{addressLine1}}", "addressLine2": "{{addressLine2}}", "addressLine3": "{{addressLine3}}", - "langCode": "{{langCode}}", "contactPerson": "{{contactPerson}}" } } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml b/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml index 0e4c4f8adf4..9db0dab356d 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/UpdateUserCenterMapping.yml @@ -15,7 +15,6 @@ UpdateUserCenterMapping: "requesttime": "$TIMESTAMP$" }' output: '{ - "langCode": "eng", "name": "automationUpdated", "statusCode": "active", "regCenterId": "10005", diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml b/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml index df18a797442..22ca2e9f56f 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/UserCenterMapping.yml @@ -16,7 +16,6 @@ UserCenterMapping: "requesttime": "$TIMESTAMP$" }' output: '{ - "langCode": "eng", "name": "automation", "statusCode": "active", "regCenterId": "10005", diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs index 0e26dfc441d..5ba21f9e678 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs @@ -1,6 +1,5 @@ { "response": { - "langCode": "{{langCode}}", "name": "{{name}}", "statusCode": "{{statusCode}}", "regCenterId": "{{regCenterId}}", From c32dce8e6fefb0b2096ca74f6e0ca11390a74fd7 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Thu, 14 Sep 2023 19:34:27 +0530 Subject: [PATCH 147/204] resolve --- .../main/resources/masterdata/DeviceType/CreateDeviceType.yml | 2 +- .../src/main/resources/masterdata/Template/UpdateTemplate.yml | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml index 6bd100b34e5..b49ad2ada01 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml +++ b/automationtests/src/main/resources/masterdata/DeviceType/CreateDeviceType.yml @@ -34,7 +34,7 @@ CreateDeviceType: "requesttime": "$TIMESTAMP$" }' output: '{ - "code": "ABC3" + "code": "REG" }' MasterData_CreateDeviceType_All_Valid_Mandatory_Fields: endPoint: /v1/masterdata/devicetypes diff --git a/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml b/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml index 5f50d929b76..30118c87a32 100644 --- a/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml +++ b/automationtests/src/main/resources/masterdata/Template/UpdateTemplate.yml @@ -2,6 +2,7 @@ UpdateTemplate: MasterData_UpdateTemplate_All_Valid_Smoke: endPoint: /v1/masterdata/templates role: admin + checkErrorsOnlyInResponse: true templateFields: ["description","name"] restMethod: put inputTemplate: masterdata/Template/template From 201c7505832d4658f03783f630b818f629a29020 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 14 Sep 2023 19:48:18 +0530 Subject: [PATCH 148/204] MOSIP-29454 --- .../apirig/admin/fw/util/AdminTestUtil.java | 46 +- .../ida/BioAuthHotListLock/EkycBio.yml | 1345 ----------------- .../testNgXmlFiles/authenticationApi.xml | 13 +- 3 files changed, 37 insertions(+), 1367 deletions(-) delete mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index df5a1d8d205..4054244fdbc 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3163,19 +3163,21 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (jsonString.contains("$UINCODEVERIFIERPOS1$")) { jsonString = replaceKeywordWithValue(jsonString, "$UINCODEVERIFIERPOS1$", UIN_CODE_VERIFIER_POS_1); } - + if (jsonString.contains("$CODECHALLENGE$")) { - jsonString = replaceKeywordWithValue(jsonString, "$CODECHALLENGE$", properties.getProperty("codeChallenge")); + jsonString = replaceKeywordWithValue(jsonString, "$CODECHALLENGE$", + properties.getProperty("codeChallenge")); } - + if (jsonString.contains("$CODEVERIFIER$")) { jsonString = replaceKeywordWithValue(jsonString, "$CODEVERIFIER$", properties.getProperty("codeVerifier")); } - + if (jsonString.contains("$VCICONTEXTURL$")) { - jsonString = replaceKeywordWithValue(jsonString, "$VCICONTEXTURL$", properties.getProperty("vciContextURL")); + jsonString = replaceKeywordWithValue(jsonString, "$VCICONTEXTURL$", + properties.getProperty("vciContextURL")); } - + if (jsonString.contains("$PROOFJWT$")) { String oidcJWKKeyString = getJWKKey(oidcJWK1); @@ -4018,11 +4020,21 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { JSONObject objIDJson = objIDJson4.getJSONObject(GlobalConstants.IDENTITY); JSONObject objIDJson2 = objIDJson.getJSONObject(GlobalConstants.PROPERTIES); JSONArray objIDJson1 = objIDJson.getJSONArray(GlobalConstants.REQUIRED); + String phone = getValueFromAuthActuator("json-property", "phone_number"); + String result = phone.replaceAll("\\[\"|\"\\]", ""); + + if (!isElementPresent(objIDJson1, result)) { + objIDJson1.put(result); + } + + System.out.println("result is:" + result); + String email = getValueFromAuthActuator("json-property", "emailId"); + String emailResult = email.replaceAll("\\[\"|\"\\]", ""); + if (!isElementPresent(objIDJson1, emailResult)) { + objIDJson1.put(emailResult); + } + - // if (!isTargetEnvLTS()) { - objIDJson1.put(getValueFromAuthActuator("json-property", "phone_number")); - objIDJson1.put(getValueFromAuthActuator("json-property", "emailId")); - // } fileWriter1 = new FileWriter(GlobalConstants.ADDIDENTITY_HBS); fileWriter1.write("{\n"); fileWriter1.write(" \"id\": \"{{id}}\",\n"); @@ -4088,12 +4100,12 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { + "\t\t\"type\": \"DOC001\",\n" + "\t\t\"value\": \"fileReferenceID\"\n" + "\t },\n"); } - else if (objIDJson3.equals(getValueFromAuthActuator("json-property", "phone_number"))) { + else if (objIDJson3.equals(result)) { fileWriter2 .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); } - else if (objIDJson3.equals(getValueFromAuthActuator("json-property", "emailId"))) { + else if (objIDJson3.equals(emailResult)) { fileWriter2 .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); } @@ -5316,5 +5328,15 @@ public static String inputTitleHandler(String jsonString) { return jsonString; } + + public static boolean isElementPresent(JSONArray inputArray, String element) { + for (int i = 0; i < inputArray.length(); i++) { + String tempString = inputArray.getString(i); + if (tempString.equalsIgnoreCase(element)) { + return true; + } + } + return false; + } } diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml b/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml deleted file mode 100644 index 0da7268b342..00000000000 --- a/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBio.yml +++ /dev/null @@ -1,1345 +0,0 @@ -EkycBio: - auth_EkycBio_Face_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "", - "bioType": "FACE", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Face", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_Face_With_Valid_Infant_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_Infant_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "", - "bioType": "FACE", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Face", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_Face_With_draft_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GetDraft_all_valid_smoke_sid_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "", - "bioType": "FACE", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Face", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RingFinger_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left RingFinger", - "bioType": "Finger", - "bioValue": "$LEFTRINGFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftMiddleFingerr_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left MiddleFinger", - "bioType": "Finger", - "bioValue": "$LEFTMIDDLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftIndexFingerr_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftLittleFinger_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left LittleFinger", - "bioType": "Finger", - "bioValue": "$LEFTLITTLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightIndexFinger_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right IndexFinger", - "bioType": "Finger", - "bioValue": "$RIGHTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightRingFinger_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right RingFinger", - "bioType": "Finger", - "bioValue": "$RIGHTRINGFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightMiddleFinger_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right MiddleFinger", - "bioType": "Finger", - "bioValue": "$RIGHTMIDDLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightLittleFinger_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right LittleFinger", - "bioType": "Finger", - "bioValue": "$RIGHTLITTLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftThumb_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left Thumb", - "bioType": "Finger", - "bioValue": "$LEFTTHUMB$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightThumb_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right Thumb", - "bioType": "Finger", - "bioValue": "$RIGHTTHUMB$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightIris_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right", - "bioType": "Iris", - "bioValue": "$RIGHTIRIS$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Iris", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftIris_With_Valid_uin_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left", - "bioType": "Iris", - "bioValue": "$LEFTIRIS$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Iris", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_Face_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "", - "bioType": "FACE", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Face", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RingFinger_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left RingFinger", - "bioType": "Finger", - "bioValue": "$LEFTRINGFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftMiddleFingerr_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left MiddleFinger", - "bioType": "Finger", - "bioValue": "$LEFTMIDDLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftIndexFingerr_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftLittleFinger_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left LittleFinger", - "bioType": "Finger", - "bioValue": "$LEFTLITTLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightIndexFinger_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right IndexFinger", - "bioType": "Finger", - "bioValue": "$RIGHTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightRingFinger_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right RingFinger", - "bioType": "Finger", - "bioValue": "$RIGHTRINGFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightMiddleFinger_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right MiddleFinger", - "bioType": "Finger", - "bioValue": "$RIGHTMIDDLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightLittleFinger_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right LittleFinger", - "bioType": "Finger", - "bioValue": "$RIGHTLITTLEFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftThumb_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left Thumb", - "bioType": "Finger", - "bioValue": "$LEFTTHUMB$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightThumb_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right Thumb", - "bioType": "Finger", - "bioValue": "$RIGHTTHUMB$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_RightIris_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Right", - "bioType": "Iris", - "bioValue": "$RIGHTIRIS$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Iris", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_LeftIris_With_Valid_VID_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left", - "bioType": "Iris", - "bioValue": "$LEFTIRIS$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Iris", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_inValid_transactionID_uin_Neg: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123HGFRFDDR3245@@456&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "123HGFRFDDR3245@@456", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_inValid_transactionID_vid_Neg: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123HGFRFDDR3245@@456&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "123HGFRFDDR3245@@456", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_blank_transactionID_uin_Neg: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_blank_transactionID_vid_Neg: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_with_revoked_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_to_revoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_invalid_uin_bioSubType: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "L@@@$%4556eft", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_invalid_bioSubType_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "L@@@$%4556eft", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_blank_uin_bioSubType: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_blank_bioSubType_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Blank_uin_bioType: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Blank_bioType_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Invalid_uin_bioType: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "ddff3355", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Invalid_bioType_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "ddff3355", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Iris_With_FaceBio_uin_Invalid: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left", - "bioType": "Iris", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Iris", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Iris_With_FaceBio_Invalid_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left", - "bioType": "Iris", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Iris", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Finger_With_FaceBio_uin_Invalid: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Finger_With_FaceBio_Invalid_VID: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Finger_With_dummy_partnerkey_Pos_vid: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&isKyc=true&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "Left IndexFinger", - "bioType": "Finger", - "bioValue": "$LEFTINDEXFINGER$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Finger", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' - auth_EkycBio_Face_With_Deactivated_uin: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$id=$ID:AddIdentity_deactivate_UIN_smoke_sid_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/EkycBioResult - input: '{ - "bioSubType": "", - "bioType": "FACE", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Face", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "true" -}' - auth_EkycBio_Face_With_Valid_uin_NOAUTH_Smoke_Pos: - endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ - role: resident - restMethod: post - inputTemplate: ida/EkycBio/EkycBio - outputTemplate: ida/EkycBio/error - input: '{ - "bioSubType": "", - "bioType": "FACE", - "bioValue": "$FACE$", - "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", - "dateTime": "$DATETIME$", - "deviceProviderID": "1873299273", - "deviceServiceID": "", - "deviceServiceVersion": "SB.WIN.001", - "deviceProvider": "SYNCBYTE", - "deviceProviderId": "SYNCBYTE.LTC165", - "deviceSubType": "Single", - "make": "Logitech", - "model": "4d36e96c-e325-11ce-bfc1-08002be10318", - "serialNo": "78467171", - "type": "Face", - "transactionId": "$TRANSACTIONID$", - "timestamp": "$TIMESTAMP$" - }' - output: '{ - "kycStatus": "false" -}' \ No newline at end of file diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index 25b6ead13af..a21b6db10fb 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -189,18 +189,11 @@ - - - - - - - - + + + value="ida/BioAuthHotListLock/BioAuth.yml" /> From 2a9cffb50660bf9c2eab5a5e6330c4c8c4b1f50a Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 14 Sep 2023 21:47:02 +0530 Subject: [PATCH 149/204] MOSIP-29380 --- .../apirig/customReport/EmailableReport.java | 8 +- .../AuthenticateUserVCI.yml | 33 +++ .../AuthorizationCodeVCI.yml | 22 ++ .../VCI/GetCredential/GetCredential.yml | 208 ++++++++++++++++++ .../GetCredential/GetCredentialNoProof.hbs | 19 ++ .../OAuthDetailsRequestVCI.yml | 26 +++ .../esignet/VCI/WellKnownVCI/WellKnownVCI.hbs | 1 + .../esignet/VCI/WellKnownVCI/WellKnownVCI.yml | 13 ++ .../VCI/WellKnownVCI/WellKnownVCIResult.hbs | 1 + 9 files changed, 328 insertions(+), 3 deletions(-) create mode 100644 automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoProof.hbs create mode 100644 automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCIResult.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index b9fc3e26760..2b21f5e0d4e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -423,14 +423,16 @@ protected void writeScenarioDetails() { */ private int writeScenarioDetails(List classResults, int startingScenarioIndex) { int scenarioIndex = startingScenarioIndex; + String label = ""; for (ClassResult classResult : classResults) { String className = classResult.getClassName(); for (MethodResult methodResult : classResult.getMethodResults()) { List results = methodResult.getResults(); assert !results.isEmpty(); - - String label = Utils - .escapeHtml(className + "#" + results.iterator().next().getMethod().getMethodName()); + if (ConfigManager.IsDebugEnabled()) + label = Utils.escapeHtml(className + "#" + results.iterator().next().getMethod().getMethodName()); + else + label = Utils.escapeHtml(results.iterator().next().getMethod().getMethodName()); for (ITestResult result : results) { writeScenario(scenarioIndex, label, result); scenarioIndex++; diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index 981fa953945..3431493c98a 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -131,6 +131,39 @@ AuthenticateUserVCI: } }' + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen4_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + ESignet_AuthenticateUserVCI_uin_Otp_Diff_Scope_Valid_Smoke: endPoint: /v1/esignet/authorization/authenticate role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index d44d6309475..19f3d7f9481 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -103,6 +103,28 @@ AuthorizationCodeVCI: ] }' + ESignet_AuthorizationCode_VCI_uin_Invalid_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: "name"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] +}' + ESignet_AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index 3679247b3e8..d4e865618d3 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -350,4 +350,212 @@ GetCredential: }' output: '{ "error": "unsupported_credential_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredentialNoProof + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}] +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Val_Proof_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "$REMOVE$", + "proof_jwt": "$REMOVE$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "$REMOVE$", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": " ", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "dfgdfg", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$REMOVE$" +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "" +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Space_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": " " +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "sdfs" +}' + output: '{ + "error": "invalid_proof" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoProof.hbs b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoProof.hbs new file mode 100644 index 00000000000..761bada3bcf --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredentialNoProof.hbs @@ -0,0 +1,19 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : { + "type": [ + {{#each type}} + "{{types}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "@context": [ + {{#each @context}} + "{{context}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index ea3ad4652f9..9193f6b1f85 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -381,6 +381,32 @@ OAuthDetailsRequestVCI: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid: diff --git a/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.hbs b/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.yml b/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.yml new file mode 100644 index 00000000000..a2a3049d814 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCI.yml @@ -0,0 +1,13 @@ +WellKnownVCI: + ESignet_WellKnownVCI_all_Valid_Smoke_sid: + endPoint: /v1/esignet/vci/.well-known/openid-credential-issuer + role: resident + restMethod: get + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/WellKnownVCI/WellKnownVCI + outputTemplate: esignet/VCI/WellKnownVCI/WellKnownVCIResult + input: '{ +}' + output: '{ + +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCIResult.hbs b/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCI/WellKnownVCI/WellKnownVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file From 36c4fef54c86886f0777d99088a9e69121ac1608 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Fri, 15 Sep 2023 12:34:06 +0530 Subject: [PATCH 150/204] MOSIP-29454 --- .../apirig/admin/fw/util/AdminTestUtil.java | 27 +++++++++++++------ 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 4054244fdbc..dee61ea8e12 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3996,6 +3996,7 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { kernelAuthLib = new KernelAuthentication(); String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); String url = ApplnURI + properties.getProperty(GlobalConstants.MASTER_SCHEMA_URL); + Response response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); @@ -4014,24 +4015,27 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { FileReader fileReader = null; BufferedReader bufferedReader = null; + boolean emailFieldAdditionallyAdded=false; try { JSONObject jObj = new JSONObject(schemaFile); JSONObject objIDJson4 = jObj.getJSONObject(GlobalConstants.PROPERTIES); JSONObject objIDJson = objIDJson4.getJSONObject(GlobalConstants.IDENTITY); JSONObject objIDJson2 = objIDJson.getJSONObject(GlobalConstants.PROPERTIES); JSONArray objIDJson1 = objIDJson.getJSONArray(GlobalConstants.REQUIRED); + String phone = getValueFromAuthActuator("json-property", "phone_number"); String result = phone.replaceAll("\\[\"|\"\\]", ""); - - if (!isElementPresent(objIDJson1, result)) { - objIDJson1.put(result); - } - System.out.println("result is:" + result); + /* + * if (!isElementPresent(objIDJson1, result)) { objIDJson1.put(result); } + */ + + //System.out.println("result is:" + result); String email = getValueFromAuthActuator("json-property", "emailId"); String emailResult = email.replaceAll("\\[\"|\"\\]", ""); if (!isElementPresent(objIDJson1, emailResult)) { objIDJson1.put(emailResult); + emailFieldAdditionallyAdded=true; } @@ -4058,7 +4062,7 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { ja3 = "{\n\t\t \"language\":"; for (int j = 0; j < BaseTestCase.getLanguageList().size(); j++) { - { + if(BaseTestCase.getLanguageList().get(j)!=null && !BaseTestCase.getLanguageList().get(j).isEmpty()) { JSONObject studentJSON = new JSONObject(); studentJSON.put(GlobalConstants.LANGUAGE, BaseTestCase.getLanguageList().get(j)); if (objIDJson3.contains(GlobalConstants.FULLNAME) && regenerateHbs == true) { @@ -4106,8 +4110,15 @@ else if (objIDJson3.equals(result)) { } else if (objIDJson3.equals(emailResult)) { - fileWriter2 - .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + if(emailFieldAdditionallyAdded) { + fileWriter2 + .write(",\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + "\n"); + } + else { + fileWriter2 + .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + } + } else if (objIDJson3.equals(GlobalConstants.INDIVIDUALBIOMETRICS)) { From 2683cf4e4150b4b1668a084074dbc20153b46cc6 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Fri, 15 Sep 2023 17:52:58 +0530 Subject: [PATCH 151/204] MOSIP-29286 --- .../apirig/admin/fw/util/AdminTestUtil.java | 4 ++ .../main/resources/config/Kernel.properties | 50 +++++++++---------- .../main/resources/config/bioValue.properties | 9 +++- .../idRepository/AddIdentity/AddIdentity.yml | 35 +++++++++++++ .../main/resources/ida/BioAuth/BioAuth.yml | 2 +- .../main/resources/ida/DemoAuth/DemoAuth.yml | 6 +-- .../main/resources/ida/EkycBio/EkycBio.yml | 2 +- .../main/resources/ida/EkycDemo/EkycDemo.yml | 4 +- .../ida/MultiFactorAuth/MultiFactorAuth.yml | 2 +- 9 files changed, 80 insertions(+), 34 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index dee61ea8e12..63c9d8b49ba 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3837,6 +3837,10 @@ public static String buildIdentityRequest(String identityRequest) { if (identityRequest.contains("$LEFTRINGFINGER$")) identityRequest = identityRequest.replace("$LEFTRINGFINGER$", propsBio.getProperty("LeftRingFingerBioValue")); + if (identityRequest.contains("$FACEDRAFTVALUE$")) + identityRequest = identityRequest.replace("$FACEDRAFTVALUE$", + propsBio.getProperty("FACEDRAFTVALUE")); + return identityRequest; } diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 36cd118cbce..9eeb34c513f 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -108,48 +108,48 @@ partner_userName=111997 partner_user_password=mosip123 mosip_pms_client_id=mosip-pms-client mosip_partner_client_id=mosip-partner-client -mosip_partner_client_secret=abc123 -mosip_pms_client_secret=Tkx3jw9INusggEDW +mosip_partner_client_secret=iTdlzpTDXehfiGDm +mosip_pms_client_secret=43EUvwmN87Uq7ouQ policytest_password=mosip123 policytest_userName=111998 #RESIDENT & IDA mosip_resident_app_id=resident mosip_resident_client_id=mosip-resident-client -mosip_resident_client_secret=UGq78khkAst6fjbn +mosip_resident_client_secret=jGSnSgsErPFNwlmA #IDREPO mosip_idrepo_app_id=idrepo mosip_idrepo_client_id=mosip-idrepo-client -mosip_idrepo_client_secret=wJ21F8gXzdy2RM9q +mosip_idrepo_client_secret=GpFzjpxln5BLnkzT #admin mosip_admin_app_id=admin admin_password=mosip123 admin_userName=220005 mosip_admin_client_id=mosip-admin-client -mosip_admin_client_secret=7Vvj405Z5a35eAod +mosip_admin_client_secret=c8G64FPSF9YoMFJ2 #admin admin_zone_password=mosip123 admin_zone_userName=globaladmin mosip_regclient_app_id=registrationclient mosip_reg_client_id=mosip-reg-client -mosip_reg_client_secret=SGqovDBMh7McnAxw +mosip_reg_client_secret=JWVbi1IyOrejsLWx #admin mosip_regprocclient_app_id=regproc mosip_regproc_client_id=mosip-regproc-client -mosip_regproc_client_secret=lntJVPztZAOYpmTR +mosip_regproc_client_secret=OOuk02uHCQdXltAb #mparter_mobile mpartner_default_mobile_client_id=mpartner-default-mobile -mpartner_default_mobile_secret=Gif10hl5sFH6WCUi +mpartner_default_mobile_secret=dGWf50OxU2D5YZor #This credentials are used to execute auth demo service AuthClientID=mosip-resident-client -AuthClientSecret=UGq78khkAst6fjbn +AuthClientSecret=jGSnSgsErPFNwlmA AuthAppID=resident mosip_hotlist_app_id=hotlist mosip_hotlist_client_id=mosip-hotlist-client -mosip_hotlist_client_secret=8Q1SLvLXt5Cwd9QN +mosip_hotlist_client_secret=LKRshKECGSCsZ7qZ ###Keycloak_User-Creation_Properties #Dontchange the partner user_111997 @@ -160,11 +160,11 @@ roles.111995=PARTNER_ADMIN,default-roles-mosip keycloak_UserName = admin -keycloak_Password = oY6ijJuIL8 +keycloak_Password = QpmcF92Mvp -keycloak-external-url=https://iam.dev3.mosip.net +keycloak-external-url=https://iam.upgrade2.mosip.net mosip_testrig_client_id=mosip-testrig-client -mosip_testrig_client_secret=aOCfcQC2dYm2Iotg +mosip_testrig_client_secret=Vvg1357vfq6EFYu4 keycloak-realm-id=mosip iam-users-to-create=111997,111998,220005,111992,globaladmin @@ -182,16 +182,16 @@ dialect=org.hibernate.dialect.PostgreSQLDialect show_sql=true current_session_context_class=thread #audit details -audit_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_audit +audit_url=jdbc:postgresql://upgrade2.mosip.net:5432/mosip_audit audit_username=postgres -audit_password=rLqRHeY4C5 +audit_password=mosip123 audit_default_schema=audit #ida-partner details DB_PORT= installation-domain= -partner_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_ida +partner_url=jdbc:postgresql://upgrade2.mosip.net:5432/mosip_ida partner_username=postgres -partner_password=rLqRHeY4C5 +partner_password=mosip123 partner_default_schema=partner reportLogPath=automationLogAndReport #--------minio proprties---------------- @@ -202,8 +202,8 @@ s3-account=automation s3-region=null reportExpirationInDays=3 # supported values yes or no -push-reports-to-s3=yes -enableDebug=no +push-reports-to-s3=no +enableDebug=yes # supported values are 1 to 8 threadCount=1 # supported values are 0 ,1, 2 based on number of env languages @@ -211,14 +211,14 @@ langselect=0 #----------------------------------Database properties----------------------------------------------------------# postgresqlUser=postgresql db-port=5432 -db-server=dev3.mosip.net +db-server=upgrade2.mosip.net hibernate.connection.driver_class=org.postgresql.Driver hibernate.connection.pool_size=1 hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect hibernate.show_sql=true hibernate.current_session_context_class=thread db-su-user=postgres -postgresql-password=rLqRHeY4C5 +postgresql-password=mosip123 pms_db_schema=pms km_db_schema=keymgr master_db_schema=master @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -#authDemoServiceBaseURL=http://localhost -#authDemoServicePort=8082 +authDemoServiceBaseURL=http://localhost +authDemoServicePort=8082 #To run in Docker -authDemoServiceBaseURL=http://authdemo.apitestrig -authDemoServicePort=80 +#authDemoServiceBaseURL=http://authdemo.apitestrig +#authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# diff --git a/automationtests/src/main/resources/config/bioValue.properties b/automationtests/src/main/resources/config/bioValue.properties index d313cb89e0a..f40dee726e0 100644 --- a/automationtests/src/main/resources/config/bioValue.properties +++ b/automationtests/src/main/resources/config/bioValue.properties @@ -39,4 +39,11 @@ LeftRingFingerBioValue=RklSADAyMAAAAWDbAAEBAQABYMsH5gwcDB4PAVkAAAAAAAExAEAADwIAQ BioValue=<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<BIR xmlns="http://standards.iso.org/iso-iec/19785/-3/ed-2/">
    <BIRInfo>
        <Integrity>false</Integrity>
    </BIRInfo>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.670Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left RingFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left MiddleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>RklSADAyMAAAAX5EAAEBAQABfjQH5gwcDB4QAPEAAAAAAAE5AEAADwIAQAIAQAIIAAEB9AH0AfQB9AgFHQEfAbIAAX3DAAAADGpQICANCocKAAAAFGZ0eXBqcDIgAAAAAGpwMiAAAABHanAyaAAAABZpaGRyAAABsgAAAR8AAQcHAAAAAAAPY29scgEAAAAAABEAAAAacmVzIAAAABJyZXNjmcoAAZnKAAEAAAAAAABqcDJj/0//UQApAAAAAAEfAAABsgAAAAAAAAAAAAABHwAAAbIAAAAAAAAAAAABBwEB/2QAIwABQ3JlYXRvcjogSmFzUGVyIFZlcnNpb24gMS45MDAuMf9kABAAAUVuY0lEOkdSQlQwMf9SAAwAAgAJAAUEBAAB/1wAE0BASEhQSEhQSEhQSEhQSEhQ/5AACgAAAAF8ywAB/5PfGwATfN7UTegsLZ+/DPjDjMztlkfykoOVskOO6qaGReIjZd1IslIgK9DCjO5iAAeG872A5IA6ERd/7SpGfimAgNSAAZd/j9mizBCh4gB5D1Z2CuaxKszbYtWWDltjbziqM8/8CIA9n3UpRoHJah7xF2Q9IAf0tewFUvuWPASF87vAMwMRaeh/xURlgEOSoYhZpkMjIj1i1lSKU3Yc1DPw0OPEpdhMU9gf9S16WoGyY6iA7dxgN9DTwQ34PwnrRhtIsU6IIUPyiA2lGmGA8V1HlIDs2kZbafIgT2jMHSBjz3MSvmxqR11nyeA8JHkg/0Iva1fLMasjNJBmfXL+MDeIlVf1NsrSrNA2rstNmxtLZUZ5I0JaZaqlE30VseWZizGyd36gsgA8LPQJHXfYdq1DxT1CxKN7x4/DgCUoC6tjiCzTSZj2MqUsIdf76L34vdLYiC83vzP8Zn8Zp8h42U6V8qqAQQWqZeh/Kl2K8U6XJbymsNrBrUdRzclJsY0mbjzHASwax/ZtiITnx2biHs674TsClxiaZPYUKsfNG48junsxSVyifMaMWpNAJUY/L+sWyrx66tSue3gC6tLlPJG2xRLluiu98XXvNWZ0VfOzAWexh/8An136HTdveJIClcXcA2pwD9A8nWxFMLriFyiCDOeBSIPOi7dnVZNBv057j4CmSOA+Jfu9AQpPfM7T65FvAKL4g4GaC/4nnaL+q3HJlCB1LhYsTUme7TLAU7x2fm9dhmiqsr5mtvlr2L6JJjWf0ckGVXMhe82DGMtSn44ocuG/efAknaPru9BzmDx1y2TNZl5EqVPaL/lvGhdpYnQzq1atGJpzpqRHt0RWhf9VNxjUCWezA+o9zsK5U1pdTK60r3I/KmvC8v8HeOhJhPBUXYFEkmRuTJ4vlRgpcrLHVl3Cxs7cMdeg/gezjhRcVfOdlzPWtVmYioJeQRo4P90BHzNDoLNhpUnWC+nUjD6aSN1Tp/iTphJeB5jbtv8HDV2uEmygJ2GTz9EeeXo6vqFR4tPJcm8P2T7g2tl6LucQUIpWLNcoTFjnXdrRlnbO5i6lMS1UK7yDbp6MDKzfJGdwXbGVuJdaU/9ebIKzBHygzUU5jn0z0l2TzsrIc2t1uLq9t8Q0BBBs6c3k3ns7jFuBBLijL3/aiVP15NvXU1h45yYI5I1KNrQ3mQ1HrJ+e6O5FI8q2QmnTQgQKFVy574FMUXlz5WgY0BQPTcTn1hybY6WDaX51knfj+xMC2k9SStVBFiG3CsU+OyZrTUFORiiG3l25xNxwRrDhjXFyVq6Olzxdkt3Xe03sFd4d/uH9hVVO86PcWvL2A7niTgC/xSKguADNkoym6u6oa6rcOJQeQHmtUk9M71jlScBajXiArMQCk344rCuloTz86NfOiP0qqFFB7nF5m/43M1egoGRstPV0UxZwRTJzzSRU/1NbhRA87D5CpkBYn/lGjTy9sODnotRFWvM/Y48H+SNTut8QP4bs47WgowI/Q/TGwPrFjzkJZObF6AdBAH3sLEtft0yj05Ok1Gzd1d7Jy4GayC+uHsnKEbsQRZ2IoGD61X0jicPOvdtbHsDxcITrhA6AMsHwKEVpWoqUFkk99ofhanoawbJAUzcO919d++7bLTTGDB6jnhJ41XO30c77ufQ76R6P0GRK7i33rA+67UCX7nUZ8J7EAzmO6wtObQp7tGRWcpGxcB+6VDteF+txOFdiWh1Bp8VDS4JeQh3qpnkiSRug2Q3AMHNGmbMx1tGRQEQhRVKo4vV/XRp7RQUBfwOBFGLu6Z9Xw0oR2ikaBUCNQNzMhsNpYvvVdr/AnQlV9hG7h62DMBELaM17b5YKrABLUF/CS1mE0rN6732K/zBu3Qhk85QS5VMa/JI+mSo2c3dSn795+cKYVt3Ab5327kuP+mY4Z0tsyCd0Df7bPgqt+ICltH5tnjRG3IJpsN+Zxhu9ahRqz9iLfS11hW7NN6FhD5Zqi/aVw1HC9aa5q3kVzPyf0fatI71NeUwV2+g/Vi6XXFfinhzopf5Hn+o500EghWpTvOz8xGKuu/Kj3/QOCT5EmlK2zWJz0Wn4HoL+pMMqmx8zhxoFrqOITAdTdgz9Fm2eqtIf5tMCw/WF0zjS0pjMqlIJe7lVAvf6k5/tH0+ZPFn6I2oMAQ+jMxdF+aCXq1Xa0csfGBxyS3HbucMzlAfE+BWTnz2xxlYTtwoVtqxAoxUAqYTRZtBMIZSSmXM7moVOUhiE2XmWNL6ZBGl8PIGoL2vnz7F+HojAw3bNTQ65sJlk7VeB8sdIJ76UQjjzi2RcsO4KX3S36LnvJ+9IhuAD3JqmKrDuIM9aFQ5faud0JW21n8wYb3UJrHPw5v02Tk2RaY/slfg/9/U3MOEcwivfGcnqj0s3bgQNs4JGBfuY4GJvYjKXuql8z9vwISN06sBI4X1hJU3Qhn5rhNQ9QZ3U9CywNSgFbeEqvDU2s8AOUgl21Rrm9HF7O2x85alVrEA6VtUfcuMhYvicAM/1Spspu/kTk4WsBozERIVq/OSkIRYEhGMSUIiwqgpy9fWG/HOWCNnykkU8MqEQgbxpqWmuA2uMA0bAmMM8KFC6jyCeepnPgN3pcNJCon/kOFtOqTIFnJ5A3Ag4pjK4LdTdC7E87yRho4zQhRj5gbg8O3Z7QY2y/z1eFVe46ahUMVq7ibflZhx6pO67VwYO4x3PH9lWT/NL9VlNS8Bz83bGXOlVZbo3k+A4FIqzw7iA1jhvEj4a3FsBUAghM893ds2M/1zD5j+cSGxsodzkJB1Yu5qmrtbyLa+xMwWuUAA5C5yu7SDuRX5usP1e96KU/jzN0Fa3jDjLrQyXudMD3GkzmdeHhnwVv125OSDx3UfU5QLYUzgtVQrl1ZKjmtsnVjvYwdWkulqIdYTYdUe8bgHwUM8D22Tm+nLy3CoQM2ZF+b59a3yHW5ZlZoJwIXrXraHm6GAE0CgAiCNTJVjLR+089hqy3CsDxYk+GKgsI5N2y8sLAtanezgRCqaixJN93d2YbmN0QmDCaPiloXqDbcbhsMw35RGpsQN6IwucDr/LZN2n262rkmmXYj143PVpiAlR++jwMRGeLr1tIxOEbcrG/3oRQlDHppJh7Uk5qWTMBxDgjOgQU0Y0OT8gnNbjxNu92PfMdEOkeMR+htEk7NNEKm/mmc/mgGREtpZT5lKPSBCnB1+JCNK9vJ8rjJNLlNnbmw/0eLlq5ImaOmKBR4Js/RMQ0OfjTjzz12w/OnYj2FVIlYolxRrh53/j4HgACHc/VBOkTznkqOncp9le971OG2er/kzpKZiy7ibvJgrhxUSlEjFNh4jNua1wFvkvVGAOIkoZ7fMc9dEWiztuND2mXntUgQoIIMFrfwxd6D1VKNZ09m54AGDiZIWagF7WIJCR3D3hpv0BJzOq/t8kTof3IxxIukYj5P2LrXoMM2Qolk/SIxjcImDdfgqGd0B+r29ScO8jqUDwTirUBJjeOYKT34rNAx+QChf/AVxqsRjI4qAmbBiYd99biVSp6bPHODBQRyKc3jB6DocMyMCwf1gvhuJVwmxspG6UlC75SANSjMjXfKKhn4goG4HBsklo4ErI0bOvpH8Qr0XzwyfXxNG0OtCqLcqeJeBwegiZMOf/T6xfsSEiEIewtXLY2ridRrU9NTQchhK1w4Jgbde5RBzvYl7hXPTZ0GrJFam2aUiEcdRLsEiJDHSNX1g5I3DR9cc0v+pblpUn80zH5KHx8loDCr0I5Rv0/phC8P8taQZPNNtwR7j/LMXtawvUM1CUPnpZp34ZWIxRFfqsWRxNDcLfqDfubIY5vRZdcWy/aBzFwekhIMRuED8/XEZ0vg3Z5RRqti71xoq7UNMKX80yx8oxtk53UcurIpIVm3ZG4+ohRyd7XjReM10ZsLtEwfcbFv4ff9ZfIK4rpE0vLtStTOF4qzaecpoP6bL+FOGbkJoF2rlX1p5l3/JRWZ4HGfO5vTOQNCoeKzr/LvYn6yGYB4zwNm/6SkT3eAT8DusX/TefaylJMpWLGI12REel4vHm983bUntQZ0fCtjza6wASxdAatrEUu+JWJvMiNCY5vOQfK1J+oYFWDS1seTL6rHokjxEjjr+xf/PC/0/A493vLBqY1eneoiVkPSchsQ7ZB7xxcMKADFf1AZQii91irgZglx80k7d8+Pn39qaaPlB3rYekb4cT9QbrsIsjUxlrvAd430addsn9oMQdyBuHIHCBfLpnWwI7AL1pqeRlUOWNqnNBjJgQ1XmYFtHUQO2sbj+dVYG0I6NzVEvTup2jEYYLogBHeKvVyXIZ38fpyDEfTEnVl9W8E34AQpG9isT1RGNHc6UT0VwoMokejJzvBK4jH+FcBgBSrlfJJzGcMOLBBYh2RZGG0GnEcpMuGLDnjZ+0HTmxNDoVAna7JVX7s26CQL6E980P2KhMHhC9y197PcmJUBePXgqaQt6LUYiT4d8NcsgdOknd8Gp/IX1btG6/lHVWML+phBMNqV67HUFTQFYMAklynQTNj83xu96B5TxwqSW8McKPQoykZ4JUVHusVE2ep1MkxBUae3HybCWodeikCezHkP6UF/p1u4wuZINOBUjQ2ZE/8hSKpUFYQdYKba50EoiW+XZqIXoYqfwrMKDnX8mY5zyiVWwNkiHomyScFSz/ICTWG2kfSmgWJN/oHctXb2GpAGKuS5cDu0OsW1RFVJlvUgYDfHDK3BT1pqrMXXc690PAGUpuSbrYgernCrwARUS2qPaooMki/WHi5VTwOinPCs/JNibVcT3rL8NJ0RWnfn2bNDNXOuKJdH8bpaTOOVp9UlgScb5Mct//AgwUuIVYeB+0sIXy7xmNKR5JDrYlTrhgNuOBY9i496zZ/4VF9L6QIW+3Kc9wVV/+iKbHW+70jvDwTNxre1k2mowDuNosKmQJAHYCd/ZPxBbxa9vk8WnxZOP+BkatIyxm1EuEpUnTnq1EijQm6hwUrHFJ6hf/F9tHL67mgpYWtusre74ChRiE0v0KYfSpR9RX0H08uKog27UwAHQ0b+B4SXiD9d3oyZwgtS6XJPsRqHU54PclLnrREOAPBil5DeVMSVvmIeXGOQdjULgS2sXRfIoX58EsH5qI78IjUcboarMTgPI1afww7oMHx0qLZflyvsaNRLUaow0ccm+9Vh2o1RfKDqS9WtmUKXKJ3L17/yssJgzP+y4D89oY+jlnbPKhIouejJ1oSeKhoabBXyAIefZd9g1ELjcqGe4CzZ0JI2ZbKRM2CtnQCFxFj+czTTL8PpcykFA1JgIw6pwATsn/eUBt+qGZ2VyrAdxQzk6HYCTQ085OBG/nhfg9TqOtScPFedPBSWs/4M9mPdreEr7Egc6H+0jcPPD4IrSDM7v8Xe77EVVZw2hrg2nEQbmioglamPgONYi0YmSe/ndtODLCMgf1wM6n5SsRD3fhNEXXa4Z6Yd0/tVama3oZOOYfdp6QOMv+c1aYlG3mOB4vF6S8vEq4PAh5KVZn82isYpDfEgg0d0mbBYHkqWnhakqU/FM7kViXLuBxR28kHpcQ0AeTVS0RM+CiexygwIOs1+UBkAl8t7tcwWoQU+KkY2mVLAD3k3LK5yb0w7l1fF6tjS5JoWBRP2V4sowoMYw49AwlMsicqAeVmR+7Zg646tWIa6apKsWP4RxVgZIQ0zIEH+bVeeOgO13JMJQ5jOiM24QyMZO3esiUfjuy1xYpslUiVvtqzu0Ep1qk0wi46I9LjNAql82NS30e+LhMc9xJ7svpEW692aGQTVS+vNnl0w3Ho9rJsmQO8E3xkvsCHBq438uqJ8CYVfrDBmsE+LnFswCLBHIMk0YzFlop1nm4/Ry/u8BLi9owkUOPWKwLQsKfJT80Q4KPbqoVxAzJgwmksQqVrbG5gVbHBUeV7MH5TtwlfkXRV+ekfs2nK8iy/HJKFi28clOfKcaFKSVDA0gmyuJOsKUPpvCRqvMDDfdsyAzvR+V2+wmUbZDZGiolzRQYVvMbKvvzx9WSI4c/0NlARvqNgCMBuv9reD0yjlwG000CprjWms9msm/8G/kycchJA5zulu4c9NUqpmSOZ8kU1bxgjLG9w9KAb+Q/2YnL3uatm3MGUV5ggUcQnUiCyFyKdN6exxaw9mSZaLWgjm7j4/gDYQMuPsi/EVAg73kSpljHAn/AAKxHqefojG7z+a4sjyfEZ9kp5qgWBkbzMAFaWGoYWq0/Lj64MaNkal5OC+1tflx/O2G0RohGjBry5UXPWfLHIsvnEv61+gZnIlswuDR+kii0vvFnA/wPBqn2zKFOk5f7WMn3yVrQ8qecHnEB/YA5lWYZzMswlS2sSc8ggvzCXssP8kGqj3K8BvaB5lujbM7hSyXCmo9ZjGFw3Z2YdcrpcDQ2UADLje40283JQAC5wj7ytvcd1+daqLgqBaJm5nJh3o4wij/Zzp0gbWcZ6bOTtDurVBJJdnn0SCkP9o5aW6g3eNUs75stRth0p9+m2xY4MJsM0WpInjZessTaUuO5sWPi7iE5osrsrkv4vjv3/uoguP4TXlA6klO2o0v5T805BAUdb7OVIMh4k5EWZIJ0SZN945RGUNTyaZKQAcmDp4T+HMwTZype7FSRi3MR052tk5VFQnVu0urXjUnL/dLBYhvd2KyEmvcFzeB+YmRbRxz20f3p91ARl4yBAB0dgHGr0YD1MC/OmajZzyZ13SMI4Tn+V136cmbZsnLMzG6X0VMJJ5LvCqhsVVIvx4tGJHzIN4nqvO0QTFwnqGQMBv9QejyQG3/uMFb9IxeZycFZoBvH+Ge1lz4gWVRT3WjTUcji8+XguEcHvrLuTW5c9O89DRLeJ+IhILBkvtNSrQ7nzGYWUYwLM3gfXjJGQQTVoeHsqwmBSPKci+yDOJsT9hKP1HVfASpxfVtxuIjlSqd7E+luGkastqxM3ptjZfzh/pH+2EiP8yGKIgo07+TQxH3ttmMAVaEx7AUOU0Azu3kiKU/yxvoFx5qTSyM9ay8Tlq/EtNbuMeCs8h1QoNkentEqwbc9vN6NWzuLrxFD4v3finX1m59zo2Ni6uppg8Jpr66Rc/49URRPRjMifVUyiiZ6ZL7DIZqWXbNi+dhWm2U9dcg0rwQJvjown/XNhQ4vCIdkwhuNIjIQEfVipJCgSwLsStwDJuBoNYoPMDDZ3Jr+st5D/OFdSavgsJJRQ4ADCvLzWQW2Ep9uF0pYjhvrLGqaXtxv96YBYRXFjsMhqaWZMUdBTSZvcWXt44R9Evvca8CCmr0MRMLkmZpk2QadnN5eI3N+4Q4OG801IfImqb71cg1XpKEutycZkUbKSVM6OzE0i+pQL0mj8FqGH0uzEmhiOEaxxMbeGZhEwqaYqw+XyT/Yh5u8WnQVWvtL4k47goVKQ6HQPo4c4ilyz540pQd+Xoqp7CELwPMW77/LPu1hF3af1hSv2YH9VAD1/vyHIe/On2fs0t99GRTvIdksq4Qu75x/2ll66/iYhaM4AdhOCt/P4b0PtDl1wtv8g8/UPlOwPFm4SJIsSNS5mYB8G35W6kgL+pS9XaMUCUcUE7TpSGpXfLrsaCldG/fP9XjEBDNu3wEBvoByeT7azhsP+oqmxWgFYkHYkKmFM4n9NdyPUuX3wVAmpg0JaZs6Ux8qb89J6kD5sKKJOn9tQ1EpGjJH1TJNZSoGPzXJdLnEFSGcSDnVNpuy8fQ2gQQlxPcscbj8Vl55zkHZYePwVN05Zt9JAUqkXuvrHszwMdZ1boM6SS+dk1wkoPmqm3oRNtYvSWoRNcaC0BK6btCjbkYJF/wU2tVZtd86u6HdFgYkK004vA1IdEm319G25doQ+k+zDZ8YfMm+rjmHDK61HzTSgx3S6GkjLY/YaSRPl3c1UDR38VoJ1BNwsIea2DbuZ4VwV364/swv/CzuuECzL0Lnrus9lfpfxVRwT2hBl0EGVeSIDJubVDbB+PpccljbQR8qXzafteednRmHIH6jrzVISCtI34RT8IemLVDUEWjkepQBcsUSQ7ygTpMKWsmcdmPrv3ojOLef6R+tHqpTSoSujDTHgq2CpYcN0KVEP7HtaN227cXI4sVPVQ3ba/85bkQOcnrmGB7L3uqV4Yx5rd7NMKDrowMgLL6RSUNa1bJk1Si/2pQsGM9uk2CSmfekLHTaAY3IhU+WdPRoPa9j5/9yLWtJAC/R1SsS3y+A/exzQBBihH1G6fL3kOvNp4QbnG6Q8Wb/CG+cR51gDKa5UWnvSn789EBTDEBPLkMA8Gx1V6QjcfIDJdRfyTGwH1t45qAE4IgO90Dtm7q+pFP3ok8bGM72CmKKmqQyzhEuuybvy41bUU/Kudb0wsDAnm3Ave4RCUJb+z4q2EiQ+K31tgLOMRAjlhBTG0/bQxxBt3kuft0IAZnzSdFsUOMqtfFDNIvkT77diUZsJjYXBTz1hvs3qz+Bl1peGNrDtHvl/H+5+GhGI1Gt8be48NZAaJ+woRWpOEBYAVkI+nXDLUPjSUI/sk6US8NIfq/bNSvJb1HdXHqoJkCQzmpg40qxtoDOtHzUhdn4C5lT4+0FHgsT4iMUHR8VEdCpESmHyaHwBGZMR4PbEXMuZsn2NA2pVG/4GbfLw88dM0BXMBmuSCc3ri9GI/zt0JjnDUH2lp9FJqs5efnPjvO4XBoFDb2/HOBvGD0Y/wSEWrz6/lpo6ss3QBG5rBVabg5wLW8yZKZaypeLZ+unGUYUOXD1PYjD5wU2NyuS7lTjwOvoCT8pE8fnTW8Uo0PNfDPoSy0ARiZjOV/37PC6+kXn0o1m3TmYFOWfWc4NYD3syo1Ykk58I+yKM6LUUDr2rbpDOMXIY+SPGBL0eqmb+iSja3pAhW0mbrYufSycCVvs5WEjBSQA1/LF7jjSRafCKbNEi8srXX3CURKIqyHmIjmos0vO+cIbqCoLQc+9X1FldzWCIITaYHKZCxAtEvoMNud+fbsGI+jh2H690SgyYdqgIANGOgqEptguzp3qQbk+zZZtSN9USluWHT787AFDSGW74rgcGXiPqb8mgPV9JiKmVwp+2ZZxAfnDlXO5JED5daK6ZlAVsiUvshM9x7BgtsgRFRQU7XkscZvY7t1oCDI+SG4JORzQw6qYhE2B4ez2OQZCYA0gFs6K8E63T3Agox3xWi5rbt6PQwkidE3cK9r5ybjGJuq3MSohNeej2Um5bGFi/QopH4JWmUzi88AdRIxiDK2jyF+26RFehK5vR4FVmHklxsGvTFdtXAMSO9oKio0RaeVc+ZkZfFgCzSzt0q53UCHOF9cZUMu4+rHYsYu4FSP7kn+jbayg8sKtLByhko0kv6pxIgjD7UtgsEOK1W/GWYpmTJxtikrIlkKQ4SJ9smhq26DIsKf4sZGx/fF0HQyFxLmgoC6Ccrpjpe3O2WYnO7ZFBvYuOxQQ7d56+6LBsAmbvVrMBjlPiaR0DlrU91L6Rv0eCjPcm0Jve9ttUn1GhMMxCepErrf3zwH/YdUWnGEKB7IuRm2fIGTLIDmJ671scOnGwWdg/wiRQHbGXZIn2OzFb9Lo+nlGDVZax8138mnLitGcYwNyVGbsNntomETR6kYNXvypAAhwcSaT6FDYPBNW+1vFD9Kmyh2KFWp7aRXq5wVhfPGJfFMDZ7KhO9cmBwpgl7JzGotdoHpBv7gsDII4R16wyRC8TDY4e1c7YLF/EqfFfN4DmZF0/3HPqD6JsKcpCVa0MCVHvwxdaP0JhgYaR5DlCBnezqesKXW1GwurqT7khfprw5D12WjmoEFIf3nywj86o25L6GVeBt4AEAVMywY6j3Y0O54nHJM5FbhcsAUpJRGTU8JDb/iMrT1V+88Kk85x5jiS1Nj9GiiR3M7A33n4nUFIvjJB1DXcz3dspm3luuUZ9l5Sb4laOl6EzTPInlpbQkYVoTrrTcYrVki8dUjetGkmaInuTmFdxyT0hVk5f9o4oY/8xee6PDjD/QhjxcPBU+cJi1chfkBhcjbDdB2fwp/QWcVN07/mtVFXHr+KsQSrVc4dXN9zR2+NfFc+lgLInMm4VGrz1oeIfLZWgUgIR8NAza5XZPV44/N3BwgeI3m0PQUDbqlmHYze09IYTDnTU6fC5mwHsG+36/R+7gFD4tJ6f1tbawOSRQbPlYwjeBJv1Two8WkOKG84gF1kE9hy8kh7t4SZbUbZFfLnc660tgu542s3lxbZ9KzyAlsWO38k9T34qkD9WpAqaNJadbmOzs3IaAJaBPbMzkNFoDbn466gT1YedGLq+WO/AUOTy9CNhNiE+mJx2IcOoEBgcMidFHwR6ocCFt7ok9qEvfI0RE7Vn5qDXqnqhqI/qxV8mJUKAMPo3EDm0uBrXiql0Qz1cin3Iw58QYkVW6dK2R82+rtSu/OsYFsQ3l7fJPAZAZnrR4Tlck71sUj5UvD0kI43Q4W5mRTD2gki2/qnhICAgIDm+rQA5LFUXs5v6GIMy4Nc02gIDVP8LBJTM73YC2O3RsDO21lX8o5+gKXRS1SRzHmRDELhm+kw/fL8+piUo2PHP7dZStPnWRm0qHmAHFRD6iZSBDPHyt7+IYqPh+9rZAtiHe9YbtHDuDMppuac1RLAknoc10LMYW7e0oMON9bUW9RmCspSWYrB/H1AMAP0LN+hyd0x409jweVSE45LOE8eBx6uzys9IUSx7dEYKdNdefjlGbqWbv29RLfnrMPqr3SfiDHArdM5Rpug+N+iUiyT7TjhPUucXlFaQDNdpqBvCQqrl4x6Xhp79kVJXysAHgqtic68aaqgxIx3pCZJUWSU8bBAL2TYDgR/3pHbYHAtShvFHKVaw5StSh7LnXcMeYfB2bEhHrNrAXXGqo95PgCtDyS7ZZZ4MSiyiOTwk8qIMu3CWm0ciFlKJ+/IyXdrwCC3N0CyFSU9AupiiFzC7HYB8u0Tl/iTZ2gZJsBY4Kkf+bFHGMWRX+9386QAzYgj6hKUy+3QgPYCdYGwT2pA8sKxprrLRV2lkBhYpH/mL7mkx/Woa+Lpqxzs+l19H+73EUxepcJWMBLDUeTqgS8cNB+KXq75b06ooNeu14LzxwoaYXqC9kMfU10K/MXebHxW3QZ7Q1mJxnk0ljiQQhF8ovvvIDjKSyFQeBPtA5D+7jFeJBMR86s5JD9sk0cTTs6Or28JnCIxc5E8Dt5wBzFJkS0BAf9Esqgrr2aOxXVkMJinITD7n4blTkydptwEH6oM2Xqdc4s0xPwEW6yiZN+R2FEgKPh/h8O89/iJEqaFWXS5k/5fR1qC5ogkHf1L429USKTlo1HD9znFt9pUHulml7xOV/6EhnQyNbZFKSbFIwb9GSSoH82XlLWQYS0oV5znFCvffmzIOAWauwhrk94r104tQwqxlwC1o0jKf2u5dzMjlSvXwAYPGS4rRMrLZk9zUMyhMpI/2RSenuJVkZOWzJ2I3kjQSMXjngUDNlFOqlps94ZOy+Mk78ATMjeR7syBjzPn71T8p32ykPnkOBcy6+L0kslO8OUincj29rBaFjeVk3VPF/r8OycsfeIz4b5D0QVfq8+/xoIcwfEczgHHJrdU5u2FwBlOVDoI9LSkuhZar+8oCyiRzuxZIdiDO2SJUvsc+KJdA6SRzYh1qEAn95hbiy65P9NjJwUGmWBP4hLZPc8XfdOHf+oLCELugQ5ytdEEe8wR6cSbWOqnQESQ1ZxXXqnzOJgK6LSPvHlZUY5CGUsq4uh/KO+UBdpVzCMkEJ0TaqDxCEzxclbMNl+B7YNdQYJn5He53nFNUGuuy2MCnxCRi+//JGvDUFWxOna7r9sR3bNGiOSz/xDN3Jqw6q3vZkgS04F4IRyt1sWqyyzVqDfB61BSqie0Hef+DP2tacVo8N/FDXpxKGEJpSLKjoSB8JuU5bvT63ssjcRRe1tg55uKBlcSR5+1q/9z66axNyTq7cy+tM1NDPmahjD29MRlxO7mSupDosWJAB6KR9LZ14/BnE0+nt2c0q1A26Odm+UMQnWnz36ChpNrN2gtQdNxLK2DvtbdbhxhzlNI1thkjWJgYHZHUv8Y/Nvq9HcOcC6iiuyQs7ISUzE8nNjOtivfW6q7M2f+YWIp3PTcnOQj0z9Un3FFqhp+H2D25yDXnttAuf2h1D5YgiQil4037kMLafFxI83Y9FchxiZZ9LM0ai79n8pgQ3lkdaEnGLkogu7y2REsX+QrMeQmgUIx+g4bvN4vcO0/ELogWOM8iQN0YixmbkbNdO5c/y5TgdToXqWLnoOEkqWdzdnizrO8OEcU0kTtmnlT4+cZMxSOjr6KjS5wtZGUPhNdF4y4fC2QX0KB+8aVRXmZgeobdgSxcxNiArSZc4xpu8b0G8vNobIg7QIHv4YkvjmZ9ei7/wYpZoNJ5O2AXYBTpJpyfPIQMJZjuZAzw9jyI0TujhMjmWCzTBHDhx4kfWwZ/1fqYQlI+jOMOIBQGBb8HNi8s4P/bnS7UN1ewIrrje7gm2mvjhG1lKiB0lLpd08Hijej+DoWdZYn+Vr6kqNBneD0fMAFyFdIZwYPMWRGWpAPFq9D+EUh1vZ2tc8S5Ik26d/Rzk4RTOksw7jMSfC4rb4uXkYpLoxK5H2YWwxS/XlXz0nTFiaWkcPs/dXatK0rXda608eeoW6kdA9eErZ4yGnMHZomPU6Mabb0VXBiytlfGOj1+nMfnPqpnFjtN7CrzJ2xMbAb7F9KEBLy0iFxchbdFuAHZzW+d2zlfzKAH/E6QawlTwfJJ0UhD6nFnYz2yhKSU7O/ABjHYi3p0koe7FN+EycyqPuiIcI6NwsuBPfisQC4AwyEXA4xcF3tFuD4G3YgDu74fZkjGANS7kFLFCA8vuO/AJgxcGJKWqw5E0gJlT8fAh62Hh73LD0dYuDqVdu6lA087O6POL36SpyCaeZKIJXjodQtkawoU4VLkXekShJY5t8NgigeJuVW3kUCr2dhjckxq9gIEGpckNic8UlAOZbhhXdKFcxj9zlqMSZ+TGztg4rPWv2RCclobBCxGHFO4VG8nu7vxr2bl/yticpiDF0NnLHRgtTYJG4VM4e+UVTQn0vXpLCbRNyoUbRSPQAfDYBRX98DzxzvIwG/GZWdcnKg+Fl0WL4An0Z4V79EWicwbRCZAjuJRFx/a1Bq/RAEB8lc8G49g7cn0QMEorll2LTscCZ8TRSttYKROcIAgdmBjL+WQbWEfSVwUlR2iVE7gwL1b3FlnGiEKjMg2LmkGVxS9sPcZlmKx/g4n+HhVH1oEuqGrkFdRJK+rs2HgoarDmbAGFLaTShukQg8gaOcAvfTAvnrgI9GtQuWey0rICpvJAbeRF6e0942GEUQt0AhBoXBXzpwwzaI0NHOR0iMgxaTiE6eKxdd+5rUSltKqGE5YrC0NyG0oE4zAOlmt66pOw8sO0AlX/RqMeN7sWfLNYPeNExS4ATT5vcDLbCli/mvbUKMUCIV89WiriT552q+AFbR5A1qUrs2Qans19igDl9SixDIzazJ2+WNitaMp+/A5qGu4tWZlOV0FofoNjq8tYfFqn3gyGgplfeG/Fe0+Y9Sj0O69IUavPoDJHIsGDbjDshRcBQEPwJGANvRVXzlUWJrj/3XFxWp6PXle68jTeOWxC0NQFhaNEjXhQfRKUwwYuFpyTc1sX+L2yL9ef71snSM66vYcs1EQM4XVSCJSpIdPlbdxowV0Mx/tzl465Erzo+mWYOlPNdYmMKhzV3ILHfmj/Tfb1UCKYmjlZciy9lYmefyivjXStsOMhtH2BUtyTHuL8vI/WWD/WeX2UwP2GJ9jMD60v9WlE+sq/tuE/4aeffqfP4WuHhgjsJfqwjJrM+tGhaB/zu7dAhDthenoQiv35IuuYqtfPS2mRAvkaJBgnffkgigwvlmt12FYs3LzHs0E6GLpQ3HukAaP2syYNM9Rtr8Ui0wPAShQ4/WPdSpxtbDFIOmvZG56UX2zo6hVwJnGUN0PHjuHKThy/9t8jElhG5uOcmXRM9dgHoBE2JNj7Bck9y6cgKPKOb/UvoLPXb2DVs7R/v1zLhYbC4bJZc5XfPo1lASkP5ydHWC4kspYrC5spaEQFysgIpgW57+d51j1XcTbSrlOWJnKaPUPra6oZWvdjRODJcm8u93WC+n8QuFzm08fo/oqawZ+aNTod33X9stt+b4X+96tXDhgrIjho3FGmntAMW5WU22rNebJ6Hm78qdBn42HIl1DBuYu9e3RNNJVhe0vaE4aSIUEsNVWfp19tpN0zNrlRqhF6GzA9ZEQ0kAs/iM7LGdiLHsxcTIS3b/ITJajtyTyUBXqujEZkR0uQelajlqxCwSWirCx/nyjA+IM4vhet+Q+tKXYu5BHMvYlKghjFw/DRI9ynZwj5i6Y46gT26IZmSGqXexH11yS6LzBRC42AiTdPCzXIgaHXL4cVHDg9wNTiwVY/1JAIFh7bNkkvI/P9SAIJ6JJXpYKWZi7WBRsVkzGIz4FPMP83VQaT2mugJ8csgk3K56U/TM46atSloVM7bA5umPMDsLB2K6Ah1zC/Qh9lAKvoWABN18KJM0VQ6724tyIMxAgPcPDKatvxgTQHFiBJgj963Xv1IFsylC9LOU+0SAxDP9Cl/04ZDGyoTYsPHtDejJ5ePiWxA/DBGyTBZwNjBZWIqpI1dDZID7XiyRdd81Ml/7d4zqKa4H3q7j+2okx5+om58KiI513Aevnqom5eibPY4vSUHCxbrts4CgcJ711KAdItViVHPeDmq6INni8cbvZSDn8oUI86llz+dH47Yxv/rfnOgBPPmk6KQ51gjwEOKcZa5ItU3Vfrk8fJc0LCjBWky3HEgHKLYYvNaYGq8RamZhDaQJ5i7kRKfoxR2Dy9KJxJoD0zyonAobe0iUjazOnKxOK7243cj41SGvGREtv2/xQta3LpqE1cObE/6xeqxtzbbwlu0bl+W0Fbj6iQS4gRCEtScURp+V0mTizSBhE+BVSI1VccK7IA61Y0OTmfhxOJPI8VocAua6i/ekWtNfoj5FSgVT7wx5OXH5g3bv/xBFjaQBUwyr5Ja+yoVzWn2gM5y9bPG1nPYdUAz9Xsn0fKfsPqw2h1PJS3hGpnHhIplNK7zcj3TVUEvzQBcQqHXLCgA417zjSMTsTzsSBblzJENHIQbTl1SQQzTw4PlRt91mQdUo62jtTDeGEfCgrEmlB/HpDsjinKwhbl/ydwzZgXmhvfsE/nSuHKApeXMKgD3ZIN+iknbkPZkEq19BOT35vltCr9j+DCrqXa1vktBi1bsnx2ez9hvzvxxtoQd98IpMaI35IfT0AKXl6XbJNUx9PXo0j531C8qV25Akhz2ID8gArq7aHYTY3q1pwvy5hdDFgy/XO5pdhsNt9R3apFd9ujkKuPrJBeqh33HDNemto8St8/Sf5Ua9xwN5dFdRe2t7rSFnrvkTXkWBVXMWp5Bo32xEkHpEbXymdqoGUOFY3ItMyC8rvo8Jze2K2CP8utfNLZ18UPLL9h3Uz4MmOAR/PCl/6VzejrUrrtmoB/8KQkWwBWuaTQ5lzcQiCAp6F+tCXnMluxhpsAwHbIvjr4CUymjS9ycoprHdS9bjYVeUMb6KUvKvP3HCEqSJfkf8wgW2v7PbOsyUfQrMqnwvAe4CrMRjctK5lnRhD+UWnn3RQ9WW2JAa9LXues8zHM1UibB2BV3uQ5S+gh6D7F+zsVs7IuaH86PvS+yqOJIg6NoETdf3cwEYYSUb0ypiLz40JXb3XAFU0SGbpDCnqRDdn1FU/rkI8CN+8Xlf2anIO1mA8VSsQbnBkv6tq4LWDHIpuuPq5rD7DKbEkmMrbCIkTzna/1bq7H5+KX8Gyu9DD8gxrGlpTeHlJ8ha2Rx0ocIWWkPNQ6RaUpUq7d03hkErBKG8GhwF+f9jKzO4mB+Pn1P+vrUdxZuDCBXcR2UHZ72w/StLMclyHW6rPU2Zw9bwBS7GDN8koL4TchITxyznE1TJtiFX7Rj6Ifa2LSIcRAEEnVFl/y2eyRPesqNN8FEztpAoRJHaSqyU9/Dw7o393ynThlaFPvKDsV/Zjp8gNJCRfQzmoUTAqb/8HtkKMXVXKBo7jM1kl+ko1RX3a6bSI16uh5WNMgpj/I37Ujm7M9PtXBuSBtcXkqaWQqmD1KnZoxp8d5gAvX4T1QGknxM5EXdFAOE0A39n5n5c9EaMBr0Toafb5FBVlxySiN8qAOyUp0UF2ueZNAK1FMFhcDSvwWjzoaBxCyT4aNJVwS3KVKLEtJV7KQDu784Oo/RhI9//fAd4tfePByi6Mj7ObW15I+WLN+nbY+HG+LvAoEn2fdcFSIs4/1H71JaKTDleY0DtI34wX+q/NO2eCon0du3jQt965oG5zSQPR7RYD6jAI/CZ/Jv1X91IIIl6B9bi7t5DjsJ6kCZVB05j++sURsqkTRqag2ZvEcBVOiC0fU7PHW+8HBwO9XXZsTUi7rbya+2FtpTn/351cleaUar91izDDIEo/Xi/BSMms/XBIjdLxyrWH9PrUsJEsVsSL/LE6OtuI4+uuD1b/AKh1hZwiVNnq2y6eRXT+yHAZVli7wVr6eJa0xo9gSZr8b+AH8RIkv5YTS+xBO2J7pV/EY5I0+yg4K2nGZ9W8zu1OE/A/DkWbZ1GFH5/6jkyppskW5fiFr0mfVyZ0QxH+8UrUby8tse7udOshHgdTqLlwr9P4Hc40BBZGp6gib52PDXqmJShXkVSt7i00DP30NqDPbdHGo49ZQ6fv5NMQ4bwpMEz9aOAhViLSmwCWEQPm4LgTzOAVt1K34typCNx4PWb2vZCjura4nv7OtMPFuKE3Q62h8Oupw2eNmlPoMa1wrD7YAB/nNRxcpvKs5LXuDbqRFkKJeSu2LlW6v8w9V4keUJ3+fGmEt60aAOGzKY/fnM/DleM22cUD9inb8aAoPkYWSAKGjPc6CHUAV2Gq7eLXnQHEzv1m9FKnAi7y52aqr+OiLVyHr7wMR23lqEbkFSxY3VCQ8F0oe3i8ezPC73fJy6kF9fNNbVqbbhZ1nM4ZVkG13BXYYuW6zbyaCqyNqhyGej3QYEr+DVDo5iTUfiYpaMBP9Z0tol4pc6NNfP0ZEsm9eFYGX5MY1DAlPF4Vlzbc0Y7TslLwBk0mFTwXRTPKy3XxpLZg4ZIWMz9u6+q8fDLWW32DPG77sc2Izc1W6jhtDvGSY8tnGrIcYJKfVaPmLDK5I4BX57iaRjJe6p4PvSUw0pNX5+gxsGL2hwhrZ1fQayCxiXQ/OtnECUxM0qJD1kjhaXDbdSQHME5NfSiJccGcF9SAR87twRG8tJoBAB6YQFDTQUJgQfyqH2rt0qN/eKMBrt01a4QIH0pr3oFgeg81VwbZQ44BOdHZ/wRTmsb1N3jeXgaCGrRS/HL4pJWvj/W8DBNEY58k7IKC4IlewZOWPPcruFdX43QpDg7mqCGXJFZwZmvqZiFxwMXPS+IWmLYtleGHFVSYZUB34ItMZ9DL+7/Ldd4KDNjSd53c3RC4IqwLn8K01yqvxZoLjbCszz0AmAQlQmUH2wgCeGS34ZjbDomPxs4sdyIbtP/M3Wgay/pVRSnwSSyk9mKoiqdhla6XOshrzc21TDy1euU/30OhypBHCQ6rZvKEX4pKV092pUynFZvWNmCJf83ZsYrIx55A6XdZuz4cChPSwHe8cqmTeXPVBeRI5ZMqGMunRKPWlemA9mD+3qDHz3nnrT1RdaUnckU0AnKglj04b+jBYYGV40KZJ+s4/dK17+YD077XApjBFxY2S4ZDdfm39v0FBz57w7CkEUzy+UG3j1OJhNE/i2kZj3FlCe5UMv2AUJ/5sGJnz27qTjJvwVsUN/32gBptuLjxXS1UUlSSj31aXBmT/26a1G61dnRovsZQRqeMiP1VnehJdidKu9sI2FPFFKCTIewn2d/k3z79RwaDa00IUwrQNJnd6tvmfOvxCGgs876+aj9Bseg3mgVqCupowzpCt8bnFgTMk44Jbqo3AWpjk96W0qNlB31d+xamhSpwWN52NxeyrJyeVp8aYBxnDVG3fA9QShV9hMo1DzpKrTF48TFm0CvkanayHJFvU8A/3KjQwpA3IyhShMQ+KeP37JvKOQohPrla+0P6/wKzDQe0jzDY0cURqAPefk4X/dYtgoemzek+LqTGhoU3FDd842w62Hh5cwS2iNw5xEL6QwU81p2/2q05EbI99bi7yturbZuW2cKKnQljSMmeC1OKrGoUuXSEd2u6PdxSLzV9DcWGV+LgwfuhV3MprJOfLqI88mlkcdOLhz0egRQoWaXoaFglRLXNIh7B01UaW/y6ux3o7jD8jCto9DTnfA8hWoGprN+0aUjWAypnXUtIXdpmEajw92JmBPX5ybDIq9pGgeA+uSsC1BYiBi0NFAJt8nav55J2SURroG+FttWadnC2e1j0o42CJgtF+VpyJFx8iSDx06c8TZdHIibTKE0WYzzjjNJ0MD4bZkGlfJVSws8Tjzzewf2CZeqWOrqh3s+7DZ7BEixVYhx91Y3FGGo82Y7OCmNgaFwyMVwT8X1mF6jY0nkJBXWZTStpGA0bIuFXfw3JflIgJ89I5qStzNO0O15tMLdd9Wd9VEmu0TwZji781DOyZCvlmRNccpZ07L18IgcoeJSRgxYpYid2s6qa50XA+v+iuaUSCWngK28ifAM4zHk9R+d4swe4BzBQk56CAhGQt4cB6aV/f6Z1UkTRoILew6XClRicF1H2SFxih9vH+63GCp6rHlyDHCeN4lV5jSgP/3nX5p7WRw+M9938bXkr1SCgquB+qkaYCl3tsTv4P2Owb+mp5Rj3i1+f8HUITQTnLloVXqDej3DR+2l6MMK5j+ZrzZCwJuSa8qkSGNSZZP0LrRhBgvLHvtwrWU6fAT9RDSnQxw1xIVhSQuRbSIoHGsTFM0EzJFgQQwCKSCOLKThpDjoYzJGCSTMbloklzy9LxguLWxdXLJcTBkMbqHP8g7Syv8LlrG0mmEc250wYNRc+zLMu2+MJUDLvuPzNAwORg7BCVyLNtKO5WR+zwdgeSdSPckm5U8HzSyyuCLInNXicR/+Ez6kXLhpzdD1QB+gAbOXplBsbJpeSPLC68Hy483M1fDycG69q6AIGYyZQHQjwdtNYjNZDfvFGZRThfshlZChVva05CXVQkWVHcoik3ZH2yaHrP2B/DEZR0W4Duh+bpujM6glJqnIJV9Md6dtfvRzbAfuRAucXbMeB7EyQdX2UCJJAnv0vYuvwgmZotMQ+UNECesMZv2CX3CafrMToyPbLxqsMTpWgsKaXBaKsvNgbzheS5iTpJIwW6W3LM/Yjq7ni1v7r3L6X0GYCYB/56piFyofaEyxrwwy1eDB60J6tHfibYBY/gL9k1hdS6unQrwA3BqL0I52QD+JDnPAHu2MapUAkdlKtIGbmfQqC3xtS/m/IjcOTpccx6ktiyOeARYG2CF5JQ8eBkPmZNvoA2kY6i7mRX1EjyXSXFjo/qL+jD7rzo0clz09cASAuIl4gOXlShaBmFhEsQq5EqjihZqCOrR+PYzPE0V8uVFl4LDFbh+AUHfkulIiEx9BVPuL2NoRqXhabV5dP2pPq8PaHpQ3sFnHq/qYMaB1vSWkPeDnzp0DaUlgIw59dbOqJ+Y5/yMwu3/RL4biGi7Pvn+RMygx3+d1utUDoDaJeMnqnuSJnIUc6i1/6NOVNYp/XQyxVVE6I2VImIgYRawVLHrm2fpIN3fH4AI6A+3+6x6gn6AMLFeNsN7UueQGdBG8OozeZ4TvRgfxV/2LIUu7G4x8yzCVUkgdgUOWzh5vW7TGyzAY17705W5m00Y1c/dTLtPp5nrT12Bj93Dp3unR0nJhWil78jBMen2U80P5T++94q3q+9WCeVXJw7EuNf9CQ7+w7G2pI1OMqiAIHpdBU9ZrBQ3FC89k89YLFlNBEdIkLj77U8NJxxAcJGvaIyfU2QK2g6MALCjBvn+jhbS7FidDp+lfbQwIPCfiPYSoreWgswG4CvGhSCJw48t/RmDROSHlHa93JK180Q93L+bemJUNu1JN2AzFWf5bD4YtrYxhBkha7Fo0EtEJKt7qjrmMmg+Ynvwqd3D4lWcO27yJdzcW7vtxrUxBqhXzrIHuZ5bXjiNgMbEFVFVlMi1iDj7dMV0GKbL+Bt8UuEI/d7/b1o3P7OlZ50G1ej0azDgxkWnV3X+4qnyY5NWynXk3mcu8029dVS3DY+9f4OYD9EsMwRn77NFb1SRKcHtFWyPX1DX/ASSNo2Su7oXaWBvB9L/tRhWvn6Xd5jp2CT7bFRw1icNcIWfyalmfU9f9OSL59lJHIrnMHq2N5c1OQp+Ny0h2dII0v4xe0FpfPHsUE7JofeurlKLnRZKYf9T2G+P54bIgq80md4BF0uGYUA8Kfv87MXnrdUz0J+knFQNzEsMzJBTCndXKiL3mALMX7XvBg7TTSo2xGy5hO1udhH6RKq4XD/NpEeLYQVGLFjh/MzlAZ+Ppgbsh2DUwNIoFLxa/XBRU9dopP57wO8AXlChUN4TA4pUuRG8Qfn7NSPue0xhnVZOsEu7LveZB/Kq9aER5uRKsys/NQg9+RGdZmwDtyQXOAE1Z9vVFE8gne+3bDjioi6mmvDTj0ZCnU+zxZtJ/1iJmMzKZXbmRve3ymXvIEvWwDiLjL7Uwplkls9zMHQlRCLX3c2qbMzWbtOzQ71wfTsXNaXHfGPAFFBgm4ghpewcWjcsaq/H+g8F+viitxa9AJ4BGXkubCfV4vVhbi7VagXpRYEiWtzhVJA9rHuYSUe2pH0cUgGaspSd3U4bCAYs2GpoAWpW0c9GAfzan/jwlQT8NjCs11ZhiRwO7rxI/P72aFQWwincXIW0vxn0JLBo+BcG8H/u1ieJywrEuDu6mpd2jTNe6AhczU5da7we5OLRuGdRvvR5zKI+XDQUNvhXQ7VFCTdqz2wODCAQIIp/oGlUrwVQ+9ve2+H5N+XMCKcqXGYun8GVX+5jyHVD++7e+dyb7dIJQ92O3hFOGJdbH79h0DAqeUr8ITKZ6Jj6KXUNN6SyPsn52Oog5lHzvC9EPp9/Q+8kPm6pqSpxaPGtGYaL7M0JAopoHR6BhhEiKwScFuLq68P2ff3s6+ZmIWpGiQJDtzI0v/SBT6uL3ZSmumJJeVhoEMUyRXKpTAHfzv55/oAsD0XsGmvaGJOLKkdsXDbZfOYpnGAGtF31kLP8ORGbBbo9qav3U5ulmfa8ibXdJva64yfhSjto9cTOJTo5Dz/qYXPUzRqX4/eIdz9GkzydEOn0fm4q5hVczFOcvfmeQF7LRmc7eH8QxCkjQx6OXvjMlCQTgJupJz4tXp8UFNoCBbuUxINjxy7Xw1bsUzIy3MqIGXkEpiK6flkWiATbYdUoT6jU4LYTpjWwabjzpKGE+j7NUCYai936sBkbBfz5IDU9UE3eGZ7N44SNUIXxU+oMVfE0ds1JfVjLmw+i2Duh7Fbuv4rRvjCIujMQUotvLh7AvzZYGGcnqZVy+pk7Yu9U+HgmLrsFdvlwxg/uNsKI94mJhv29ZGkLTutrXk2bKh0i0RzBJfrW4tUtAJqd5j7rz2sxujwUzO7J6QLNhZo/HjQuFhAH2BxlPdIjHZ/N+FPHogf7S8+LT/Yhk/pLDpxhZYD7ArOaGAw9nt2fZ03K9kSAmBD1D1utquHh45ksYfR+mB/suxRW7culexV8CyAWnV6VpvjXMEazXd66e16MqfTiCvRRULPpknwN5tKSA8V6ZnyB0a3uEDPsIQxdbR6dolvHOF/fSbKB0UPuzxt1l7SRDM9jHlWZBMQ0hQAXBX0KFQZs0LDim1mx+kgGCgsIpQ8xpc6Tvw4pvb4E5Q9vIRCFQ5Cfm4v2IGGclo5+oXno8I26dYoZM4mUu4vUunTtmrM4FLmmOz34vVF5JG8U+V/spc8ILrRRmk2CuR/4J2LpT1NbkirQIBeh3af54bQFBn5W9gJChY+LiImgMKRvuDv3w++Y/TN5jQAqd9h+FLsZz6y4MeZnohXbd0a5n32WMoveVHyXnJNvDouXfouf2T+Rr2JuDt6Lb19/04HGsfcAAL85hcpjLdVNhRa3W2SaZ9bjo8iaWSiiaNx2ug0aMZqFxOQ0G3MDpxdRnRfIN14nxFj0uJ+ZjMEl8co+U2bUA5llTOZNkiWEux2ehNwPS+4z9Eb8ldCvabLCaereNRBBoYchKzZfFDKRoio765q5xycAn08GJjRO1x/8dadG+wupAokLU3YwTCKZMjCGzJIIGj8AhGCCMDlxxqQyyk8ne0EEleFCq+BXSpsXwh87u1/rtsDUqgWUuKSXzrlWrd9631/qqUnr9Ji0dxsRUlLcyk5BvfB0kdjF0kkiM8Afz1wgmfL+MHIgtcOk4uWRnm/Ow4MJmeTkCLRbI8VUfVOQ2d9OdLt0gY1uJHEM9IC+jpGxDE34hf0hwGmW/Z4ub4j5bA0oJjJWNIPl+j2j6UpSeSGmFbBZ+6uxUcqa7JBneRbPO5RMgYEhFLas9gZZBln+wVUTtbEEMBV/uuZY0uKCtdf3hXUGxX/x8YVnRDD57ij4YRU3JlXVzeEwbynn55unDvvcPsVL5QpZ1iY1t0BjjO23Fqqw/g6dUzSLuG4Fwd3mzl7pGEH4i25vZ6B469ZxGQJsbC7kMp7p9Jqjf4cVk8ANalCdodapp5u/h/HvhQuOBsK0fujo8NpwpJogU8vGmCF6rsT1LNJ9+PSP8IRY7S2y1rHpyvec8kBtMO1r6j3a5HJaysLj/fCW2+UyUn0ZE1lPT/n0g/QCH5fd47pzia5xlE170nzNrtZ4f1knplSg8YpdkdJnHqyHYRR5UB82HLDPY7hTZ0tp0C7a8DtJFofoYQ0+3fhCFZRY30MTVxnYatmgh+kbrrVdWmZvJ7AbNxqv5lxrItVo9k6VnYDXwFl+SsRyEj69E0Lmack7zaXVfk4EgY1hNrB1f/wCYnnQw6ujzfTV94uix9WRf53d1sBE5ojqcMJ/qyfUhjK1GbOopurJvhK4nd6mBTD1N7Uuh+jmu0Yhl+gtrlDytCvdoBWjdjmAsSltqiEjsZBWt9TG/2RG9aCnquPxhw4YpqXNMfm7NVyvO6Q4xr8CwAnYtxFtbtgyL8qBRuNy+n0qIpCv6buRCFLLhxZOb1PDGRPxIwWyeD57d4KYC3wxyl0nrq/JqE42GAcwdMPigJ6T901mjMSeaoPuFTv3YX+M1pJvpcStV1zcUQCC+cUY+WQONLT5dDf3L581bkLTbJ2RClQvNE91ioDHOnCut8bS6H4gJOEdyLi6/gQLauNO9h3ajFRN1U44RRUsmRJa082LLwwsrdSO/y5OcKB7bQOyNpfKPsUBVTTOvtAx15phOoEXGyCgvNu+iB6yGy7Ys6VQmpPdKD8cxf6Be4iFm9cVFcz0t0hkSEZweOzQUnLUhA0jlknwxjAZkleoZmxTe2MH1VItSUZpLRrv5bf2tF5VcHTz6P6lCfl0s8ClYN7k+dOTe18hlxmboYL6DZyN7/xM4cezxxcuz3R2nQeFNp18UFerhHJMm97YjDq0if57V/wfqiVgigOLux96U/aB4P5i18G+JfWZrQj/WhE6Dkjhw8FttH6bJ0z+BSKcNYbASgZcptxdS023zuFERNDpy2ZfXNmsUVYsAHjAUMe7SnAp88QU0bDdhhdDVI4rkZVFWfDVWgdV7u246ykW5TIBYVTXZruhAZD+Vu8MDhiKDwgRTxgXLjcGjKb9MEyf+NB4V9ik1Hl8UcYN8flnvu4N3rG/u5mZrJs1u0hMUe+YhshfLSeX3xcMTfaN00MKj12u8iTdcFe7SA465ez8hcdbpdHLyicOhGKJN0uD0VCsiuaagJktJMQdHrqynP+x9ZlyGGrQPIymzdy4dgkezeYODuc2kvXbR1QHmgeojfwBmI5B8I38q/IUU5EruUWbbe7L7fsvjCtB6BiMWSi778z2binJGYcqcugtihoWbPy7KINt+eVafdoE8qpH30fZFDp0Qqxn1jCPUKrii8jMuQ8uDUz0bx2NtuCxv8diuDRlX7VoUOwAMm0Q9GfHpsy6yC/VIjMJ/usQ6xahEcS1n2Sto8dkaEy7NHtPeKGk7Y2bac4Fds+HR9BM54YZngdSqlIaTHuQpSzyd4CrEhJJqJHan5wTcpdIogB0Wfqn2Umd3F7iArDnRE/6MZh5bP1URu92DFTGsTfEOX4cr8TjoNSsWFJIcQ7m9r3cM+PEtB6y0E1MRc+JcsGy8BTICzkDDvdmgVWQ9361kBmBwDrFtfO9GHRzzTwzaPK0uapgAZUWdTu6pOOx0aOU8RahtXxQ8SzRKQQSnaMKeU+Mt3G+CaXy36Vor4lM9xEVZnfLDuiOyDn3JfDsHdXuoLYKy7njcsSR2fySDcZUOvQ+wqdF80RWPgx/URvQ08JJOat3iUyiKNTItjiMRysL+fxlRAO4isbZUmSVG9OtOM/9kaae9bL7pN0bLf/JJLjhdzeg7TRiSnDGvSefIw5OkFK/oMOnGiCx43qnkMRKgG8pb8euE+woo/gqaSsLUTa+coQJPzqKs93od6MO026wbZUvLXWlq4ABPd0fOjEQwkafmI09Cz4KiW48AIDa8ZP40UP93wrHYfySUea3GJJiXAI6gCwv8MHFQHsyvKJ2RsobaQc+xVt2z/GqjJWW1Q8e2JoBmTrws5Rbg8rhOjHkDxWbOjiVoGCJ+Zb9K+/ujhQ4gQYB3ZLQ2bT+WIuBq8yfUDJyYtp6FBC3QngTWgAOk6pmhqjaZRy9bLbbPL9SQhr7jbVDdTuldTSg9qXsxrG/Upg/VCjWzUnWwwasuLyDNurOt3WNrIF53Q3Oi66rnHUjrf21Q7PcW8/Qdg6ykkT8poEVa0HddTvt2eVOd7ZSPFUlyUvr+ck3uOMH4LWG5l2E7UjhmopU0NA1uhOZk7HnmvxlwRm9MwWDkbcSDAOvZiSHfg0pSKcHKxIFwidghEZ5DkWB9O4wqlL3ejFyLcM/qj2+GK5d+oWhBFYGpayZCWiqmJnKQBCA1rhKdNsQnoiOATGGkPv94+gesvL3bHwhM3rIsrZyzFwi5DoyXF3SDTJKWDjmGHsaqT3k7vCsJn/HdYfmrxmxH/FsHRF0ITn47vm3FyWB7E5k1ux1qbnjLSLuA409qPGI16sqJdAegk1MwBIQHyFoDE0iAcHIFOmsH+JIdtq6ukfQ7skRB4PndulAGHZKSAatjIhbFvGoqxe22xH6SU1cfe8WceZsdshXlq2PnzvQpFlLBEGXvrRjQN24znTcZxRCn7zPr69lxWTPJQhSdl3S47Aw2SvhVo00+xPOx61G35Lfk9AigTGMHC2nWRmL7DJzSndtpoM+6e2LEQHko0SS8XLJxVEJoeDYn0OHmjGKK3ktkHF+GrRWAgf4vClMGCONijL3Tueq1hjmAdzZRzpYZyZb8974aQkNC5b7qRoEc4ojnJKBnPZ1Yt87tdbkoPXRnWhG1EklXg80yu/fM/NSlyHcj0w5WAfozU8+cSdwnHSMQDCBbj0dpseCQzsbaAMtH5fWzZ8acU3lRX6TQicPMndW3PTKXpoMgIbO7fyvwaBSLu95cfHVAj/tzmIWva2JwWX+O6JoAweIxLAe5q8bjbw4xcdugUg0r0WXjdFYQkkTPb/csAGgZz4ulKOOomoExAKd/TWu9R8hX4UT87ksoeC2Am1UgHfj8M47rW5FDcHLhqjiGru0e8enBjQMgm9bZbamaSkFFC1pHj+7KvMpzMKT+iEuaFbC7yy/HcCs/D/V4Gpu2OqLqkXm4ziRVCpMLShEZrzIDI9UppxD79N672LJZ0TEiTfbMbzJFcVL8VFyaTw395JlUucXmi07Nqy9R8G45e0p0p6kRYc7IDLqJ359lsq68SYzh4lmnu7jtlRdt+Eu1uUflaZ6o/rva6bTb50VORjTkLY+BQ8UHCRHGQP4oL3bcqrxooLGPXTlciwIp9EsowqqaC6HrHZ2BEv4DfSgjL6xDdGnCjcX1vy/aDQoI8az6/RbiYjlXOGL5Wi4whl1vN2aA+Pwj6PjXTYIxrP6HFpqbDhoda3wFAbj8M4dEqjDfW38rGaF+ddSyOak+2qr7Luf+XQ67KZ+zNYVgPtTkPJtIkth4fCj/bUY2jWe+6cilausBdAqDKjd0ZzymdDovr8KQB2IyXHD7XMIZR99odFR7LZYEbIz4qjyFN3QI3onPxJQlkJqIwZpoNy+dbHBCKSmcMUM9xzcGy1KvVKC5v+D2d5CedDN0lVHWlX3GZ4a5VbIGQblwr3FDWrxDo700y9CB3zrPTPx+5KBU4bUnblQf5vpAoJmwGmrMP7mZy7LFqrEL8sXzfhF9TtBv4Wcnn3A7GIUQ9puMDUV//1tTiG33lAwnfSTizPTnmALpL9W0bkiVsgzbPvMHZmO8wi7fxJ3kwyXYG3eMhTrtNPZpHoeR+12c9aTbMPJwsA8TcVk4Ft7MFHD3hXzCeQg+m3kZtW3QPd3kWgviswiLva0jMa8CUQ9j2dEEKT8/LZoVrQVyp47DuH16OX40fbAeXanFL1SPZOPJBKHd5ag6ZG3CcdtN1VKh7kIaTMSoh0wAY3Qc0MMsk7AvUDp83n3/X3NKngPThaQetkGDcOzJa0qbPsiQwbh69Wtf/In3CiTGRZl3fwKamg8/ZDdEBMeP36zo5dg69leHVzSfK1ZSb/4OWejrOb5LwSmez2QoT2cFTstUmrbkauF9ET6853OAjG09uRbS8MSI6eSvwWmp5p+2OnG8Rk1vZ0fqzAT9F4OupeFaxpi9lDSkJmSUjNDJ9rfJtC9wKWYxeSkxExx+4j9eeZWNL9wUjvgedpLit4NwBDUr20E9/e2oiUoUZnU70g4HMtAQDqlDR6Asyr6rnnQkNhuPhLYpH/63UEi4w8TFPu+AVZlm+uqpxRsirBNX3XTMLOa/ZU2DKWgXnFZxIyGr6J47aNRDT0vDteY7KYqhVkw8vx+8KeHMB3p7yp90jwWjqg62v5WwxH9MIn8linCaPE8m4IKuCHMZq53lR8EezBktUdtBXiI3TMy/QVAV9yR5oS451eDP4MTDXyeIDc159PuEbka4hpNMTKoyiFv8vxTmdsuPteLFvSXywv5zV/utr3chgQJ9g+oRljFV9qvP5ltfhIk2x36NP6MrPX7zy0CTJhWW0z6Fs8jpW+TiTe6qaGUOVT/04CQsAwpkSSAX49zNtN0YUwMzm9xmJDd3/r0kygfyFdjBNNUekqPjmGPHECa4hWZbyPO2OMjxx3C7FMd/lOog+70r24PdPJKoefkJmbIf92muwbcvKU09q9iso/eHRQpfu9IqVwE6FVV7BybgAU7ejTF4Wlhv+WALxydgt3nqhsbtIY4+DY2MvYc7qoyZj9npq/LRdhwqtrQ2DHEEPqRgDE9zrvX44oQ9pbAlCEzISDzgW/km1zrbBiaoi+qLQHJiQtQ6kfGxeaOrRUDFpqUVukdqyuY3zWYoP7XyzFgdQR+0WbgUxkdjP0zpXGPlGzvfmj+4/FfV4m5cmwC49qMxa+lZX42D215M+ZTZsKBA20dAFHYuV1Q3PFyq6C3BVhhKODfO3DoMfcWVI9k7Ihf+MjypIHiXY8wKyfrKd+c3M2SZb4JDcpEBLrBexy9EISpxz7I7DXvobPDzSVUQ0It+rdjxJJHe1zSRwLH7OVZOLgaHijrMkecMYc6vnHAq55x/Lgk972UAkhVz+lRLOzel7ht00engQW0jzt68yEMudcl+R8lw33OmiMW0ilIG1ErINsIQmvn4CDGk6GNGy7tP9+Awier7pvVSFzWz5FAkDUBZNCQ5y8Ui6JPvc4boGGLXhrnnPdzwIwkbysnRN2vgkoAekDEz8PCdF2SUJ2hg5f+ATI8yfAFv3aiL+LiSoaD+giUrWrFUWU64ih9pjeyiYHKhgifpT1RtTDJ4wn0ZHTIC35AWtx5KoI+VksiU5DuntrJukFNT7wS8p1acoZzidah25T8K4Jo3wUxZ0ZkZzXQzhNc8m0aHRRcHucPybvTBMimfQCTHfx+kOMUk2BYZzUWZi/mKJXpHEpzWl+VvMiFvLDDD/mOrj1PczR5XDtfth3xty7smMgXD9iaU7mBPjXbQ4h+cQwJf/QPisjObUZ2uyZ6/TSDvlRt/6vKCICtzfiBMqQ6kJ+wqjhnLCoIwjkuXtL3Mx8BvSIWWyep8Wkg4Tv9mR8phM8nCNYhgXDbfRE0hZIZYKauPge2SMO7ymVA8ThQPOt4p3tjVR5J5H9D1s0/SlQL+ug7EUGnFCewDasj8yyXlLwX3O5++qrCSK9jTl/4aLKmtn3AonVHxA9vgnUxIVOdjZFMf1vsjxIHJ3+/fPPYVRT6zM/AsYKFYy7tEerzWPW9zNTUEYn6XrT3itE9d0AdcJxunGFFR8lFgCKbFAb9XNyjp5BklLfGRBUp8V2yo9owaqlwC2aBdcTsIjrWLUsvak9Ltc1psqs8O+cK9aVLqW48w4OmCkCNt1qssO+BumheqmeMmR/jnVxcuqxkz2IghFMnQmNJbmNZnTWrBayal3Xzt+7aYEGpx+LQTW2dNmFd8NQVXwD0MfTmDpbmWseJZwA0xGE1X84KW4Vpc3baJnEeGgcv+lXpFg6R2qFKJLBTuo7hLBaQdtMsYzlkiU5BBV7MlLyLy14VwN5gamn5RpSYdnwWFvNXtjPBh29tzIsmdlYLzE460O8BnlGvdlaNnOpJUKKMLSObZR9lFvEMLYUpzY5glW8Wx9WiXADuhXEn+m5RNrIZD3AVAvieZZQIUxNXgn5WSCfCl7W/zh4teDVuCcbDEjAbYCf8yO+4duVtkohlNOW5NIyfgC2Ode+C1iIvgcJvBTbgHO01x/jIz8Q8SwjZgCXQP6h2yGF4K7YNX27h+xsfTdg692xdCkntkrq/3UmVV6EcW2MNAhUdG2D8MeVa5L2TeltZa/yW7NrCrfTlwUkC8q4b8sIw3xs17qMwiujKHOnkDqMthQOeyDdVT3KBOyQ0YQxKkjQjW09EkhUAoCLpSnz0hDkEVeP881SZV0fG1uJrCWofYJJonB1wIlS3t/eYPhlNgnATkzPV/Nl6tXDJRjtE4b0rH3AI7xeTppphvn0UIZbiL0vebWVQkInZtlE0wOtafYI+hc/cFppauJ1OU9ERs4m6O5IyUGsHGgFhrKX/Dj1c+JeepBLI8GVblcBufgcPaxvYoZXULm9+hT1Quqiz7JOKQA/AvYJM2c+FCVZ7Jv5xksjj2JN2dikUJ5fIcxQfmi6ts0wLLinpWpfwbvFFEJcSpvzphJkjAwkxe/kU8kqXgdbxECFgPj8clbNu0TLM0TvP7tSUf1M3uqCTIwd698sYyw9qtRjhsrYUu9Pjw3GGaUSKN990Cg/idXC8iQ3WZve3oteR3xbfMgn377o5I4jV5VBTUhRh/PYLlG2me8U80gP0Nz6ulf7sHmM3OVVAA73Kht0XxT1N1D7xJkshYocyOHuSbuX5CllRhI1/13cWopM4qlc9BiyuWgQnK3guNpOmQ4mHrVMdrMRgT7NsgQK8gjYCr7SsFJyjhLHi3OWz2jIHaE1SmCDiQrq+4xMwKm1wKPCNbW/oG2D8UCJ+zJuALodLtpDnhFdOMlJFKoTrJASduFUPzT4uepR6dJz65sy0JlVKkxzBupzl9MGTlfws3j1NnH8IbjsinW68avT8ms210fSA6laEf1CJ3D64yHXxkkvwK0E3oJgQg01mMXZ5qmIMJf3hNej4TPxcIhWeCxV/MtW7m3M6puzqjb2TOMpnYyZLDkiKchbtZM26UXaNlEzzeNnvsO1YPB/q6VIQVmJLb53ECqFdgqFVW3TjlJK4Dy0TfFN2yKOXg4Z5w+fdcw6WX3Qj7LyjoApiHtv9cw934h753hXEwUzNWO6jEHavSrC0ISz7wsNxjP7GQvhiurfkPsHhuj6kO/IVvb6IIYZy2a/CeFHZxnPKguljYSTfdkSU9PGhH7rT+YrryWgz7H0jQ4unhJcs3EKi62kH8FHiJiYpojIbmHbc2sR0+OUKfDPWIP+kswyDFqPbAueIH6QZYK/Glj0sEfmR/euM7srrcxEE8DXcxsCQI9Fjhl5/8cQEycLGnMb5FO9nwZOgvY4QmdeavUBPKlUCRXVwDXf7kYA77YrDQ5v9w7ehTGN2ckic719jymBGUbGlc014pqkR4hWggfiGYY7iS3WAXqMpPDIfy3oMzqodrXutH6SDbFD745IoydwlOqhXsmJkhrDxMpb5kUu7F5e7DhvuqeZMThOUwJrJOfs1kFJh9At5Kt5wYJR+Zg/SLSixEVQGg95PTMdhDlXWd+syyKimbi+A5HBQV8wbeW9F40qk3ohBiH1QTKFUhbbvaSSc4rLXFs0H9qgG6zQRy2XjXR9R7NBOmLeugNIMeVsdZWSfeeRUvnuHpgyOI8MYk5fyokeVf73orm8afx1wz9KHFJ77ToALHh7EkWkeYIV9qwAW1CL+5jwVYJGXQWLAPUQH8eW7aLMdrCjP5TVC1bBiiHKcY9Ih534V/5mnn/U5DOp8LuxVgriaOHbyh/wLeUJH87eALILxWkXr8/VOosEch9KrmngTki9g71AkovEsu7P1bghspvZ5lBxKuHQRK3L26xZge3isSJrlZjKnHP53pH4cqblWWi5q4HhdOf2S0u2uduhU3xOxNO2HQCU+NGqfVmE2Tj8uLbp7fyLg0c5xM9FEujfs7QEdaRTjNaB6cd/MzE0Gn1FZX9PHuG0xST7hRpXqo11Dfl6CkBmKEjlc6MyRqYxRyBnLhIlpcQ6LkdLhCCwbp6LHwMdRcI5J5HeB0M6UPnkLk43KlmYfuWAOTmzkK/kXSFb8JD/OheuDD5ZPkxxk9B46sblRXbNQKC4bdv2XWJGkpByUah4heR6HUoS7NpV9Fh+vmH8YFOdYPmpSN1GPMOslAlwp2fWs21pL5zqHQzgxuOnrkUjh1sYO9r0YGUKYdIDKxOKTTVoo6vH2mhOHtgCEmXLHyMhNuKpS34QSc8sXphl6Wv/oHyUn7IYvjD/baovnPNTlWJN+KDgprgd8EW8iUCKS37jfpDpr51Qc+xKyFlNWkBSX8ux2/o3AksY3G9yzpHRVO+N20LbXG+686RS1u40RqrPg73gbBkHefPMFwfrUKvUL9oc1/YXzzwbU/OTxIraKBJDsPhhvoezm5tQJiBUVPLQriKzcdJpAkuNGyW7A0pP9KfOgHwJKGlq+PVgy3TASPtTAjcgLVhdHCp2pKnJZStgUXrMBYYa39ZyD1zHQkKQJ6gwRHIeulFn6DEoSQKb3BWZppWCgqc1fcahCk0FVY0kDub582BEXPvJLwvw4glM3QsbbDvIVo2TTUaedRzHw2THifvQYLrvmpeOTVsFc4XpaXJXx6fj9CSSYsqdQ71yhdOHd4oZFfYJfwf4sU3++Y2+eWpthSy5ZQLL+PXCGMThA2oAdwQyo3t4jVN5bjnz8jR51gEtUbvQ9mk7LHWzvtU/8+dptosQ2cbWqS9PU0lmWA2ktQyh6VfVu9W3M3QgDLKMAz3A+P2FujnL7sw60uvt4GBnWaFJzgfPr5winNMVMwzD5Pd0eq5E6GmLGXcGXA4ID/a7fAJfSDzqLURKDOOlqXVRchoudZKXSJMofjD93bLTUWfe5Tp7dsnCFiXbA3mbvzlxVEDRn0BwCd0MMu7Y8GkrszNRL4yqTxDPhYmxCpXFTq8xMd8FcwOJvgxJk5G9y5H3kel68QCMcYcXXPRyaLp8rqX+R3dW4DLRxCiVAtjQkIQ087fzpBfvP9pAU/k7992RT+v9OCH1aWat8DGp8j9IDOTW8gEvHg8E4GnH+cyCxaE8/gN15q41rKi76O3jlD6P1jThicEnT+ytgYx8djZ073WSauK7kt8TtLBMNKoGMwAeqWydHx8iFUixodQZguf9jA1MVKoy/t9ABig78b8KpVwb7DNUjSxuODLgGNjP8Nyyw3fyTbC24+Ip5ufRT+CfgohXITV5rsAhonwPYJddYapeL5Zm3uhw+zfxXMF4xMLl8WrhV3V3Z+EGtVD3NyVtIHBkFIqsAKvfQk5hCCVOWP4SOp339tuZ4mV20bbxo/9qGEZXlcyUbn8Th7BIvvDiAcz7vd6O8MoSce66NuT4Xv6qD5BplygsczzOIzFHsvrdAsJm3/IZJP4VQzfq5LC0r3mP8t+xuKJkS4JDKNugBkK/p+tWnKbTc02y/8ROD4laNBHIOwbtkPChwElTX3q/Stdukr07UCDdVj2e5qxbABFDJchUmTC2spgfwb4P9dUSSjoo1gdOBU3y7s06n8r1ywZpy1UZYzhaM/q5f2XaSxbw572xMNf1N5og/8DjfdjI84rL/zHZB87hZ8XGhTU8B/d/W5h66WG8fiYI6weXkgq0oYUVjf/3+wWC+E82qygUl1A5gfiJUWJnWMjKSJhbcNOqChIHdBPy+IyQSFui2rRVjT0c1Fr+qDhcUopAyF+xAhBHMTeH8pjNWX+vp3zyjf3wjHZB4gWfsTDZL3jF7jnna095kwm7E8TM46Cbf42vEVCqGV+3byOFyZVCAbHzCV7TK+wBelplxj/s4VrpjM3Eli5gWrgjIS0xCLHzAYw73Cl7N+qXl8r8BenJWmzksOXJDcla3yOS9VHqSEN8FJolt/f2bK3OPHkv4H5UZD0Tbvyhiq6OZznOWc50x6omQvXrjix9s7rExMp1/pmmblDns7hp1Z/3FJ/l3fnN1pRRQekPPzbuHAQCDjuuuuxoxGBz/poeGuGqaYmROQeAvpghufx38pPK9EWv7OwVU4zSflCBITdnZ+eu/J5cM1OKIlmxM3jqJN95L+iLBcqT9nBZh6TbGQVO1MWs4Snj/QLbecHGbjIeDwYhQv0wtA2vj5RBw16h+SAaIRstPTyjNQOhKksuWAcFv4xxghpIDTy9PbPEpOgAN+QC+FoLFiGQORY4KmgofbHSruYn/ANgAfXH+r2ovebZfbqAYx/zUxZ0l1s7KczeuXQ34xnr1t3ASIA+B4Isjig/Pe+wjFEYLmeEX3T6wXcDGqPgU793k0yLxNtBDh20SaqFC4r+7kZThicswBezAp18c1azMENKAatBDlfrJFFx73tcZ0PpRv3JaL4rC4mM4b/3+UmnJp17TLV7rS4WVPIFQz1Ci41T5rK9CbDH2gkYHIJqm8LdX8Irac69KLjU0N580KQkFumCRR2eDlebg6NZwoUiXyeFsPmemRbRL4FS/Ku0Uiqo3jZ6ou6/P3rYJtI6AUnAMMiDOqFb0BAPhebcpYDkwtCo/PEuj9Nx9Jfx0ymy5iYiWEmqoN1v8Cnor3INXdHmY6iWBc2FT61K3QO57nsJruPSql7yIiFXU+ebLZ6rLknSxRyH6wLL+lgwsCKldaggAUdQbTDkpWipno+bD6wc/WqpFxe6mB7E1Zn0CcOM49gxhyk9LiTnCVyH8JDH+a2wW4yK8ZHpnh6t6j53ycDWmSBSZkASo49vyQ1UCcLcSAAI6Y9UcR2ARwoO7VCK6XdbOiWr7DJJWV7IUHI5ixD61ZZTGj4qGeXyKimdb+/CVcvjvSDPj21UvNj3/0DNmbxU22rqbt6nXTtUzDFCYeF07Uee1RkHAxFqqO98QrQDpOwDTvoQVuvC6ti7SD0LPV207vqd7JruNalJkvY1BqDTfzBQysciU5SNVaSnq/ZSE/DuJhrdMzJ4MwxnmZuzPFW/qAFmsln6lIYWqJTuwsGYRmi1+dTzK0ZUpXygqktjkyS5Af73hs4oihO2lmtn32xZ6ElWRfJ8prenDs5oFWLHWem3lWTm3aaXNp4l3HOHN/kQ2VZGDWsxQbyxhixFjaA4sf+rQF/jb9NBIngA3tBVCS6SyUdT8cLsFxptV8IK1A0DqXGj8Pn8wG6BIJG5dxLExuIO81L9sQLVDs/hhFgUxMA4GzQ5neaWDh8UnGylhACiilfPm3hwZUCgvzEVYdyvxtl5qhYcEgVS7XmOPQAVcxg5x0tCiS9tkfMTbhvqetRyQQAVPkqc4c/F7BODNeNcbJ+d9kLNUHS9pVhklrlrWoqXOHYHx+jA+mtdIOJ3HD8nwA7VlCT3dvJXEfpKdMaMJnGOv8sq4usnjNzKdnhQWPrr54yWD6ItiJ4sEkIY1xwmVkdVqNUkLemXIsTwIO2+QdZNa2e6EP/GqJHsKrk1UgKkHMRAZYomXSNpTz4lCfiIwtqBWaiehegWR9LOFhoB/QMSqkKET5LBKA1a6pZTs93EOEHRcrdOzheTNERuAiqEeM7WcPmvv4s+FF6ho9pHWQr/Vl1vO50r8gtr2Vq/msqvDcIt4sz93S3hUm3dzZ7VIbntVZtjokc/YWrb/n4ThahhPq8v2vwk+T+6yHIQOvGAihCv8cA4fnchWr3S4e4eXqosnJCPXkjaQDuVlfzyu3onWieXE9CTWJVHc9rKtFqMYizzHmchLok76RrPJkFovmG/OVGgcK6bdZQ4hYweFozvt2YCYpwb2B1X6zhv3WN2b7t8MKFFKgs+etPmLWOMGHqEB4tluqurouxtN0WoizAtO+NVl8dr7UyOzEPqVGilcx3DmfOPwdpUTrJe2lWrgHzjfRlCGlM4jO0uqoKmrKT37a2nhoImZoC7cnV7r5eB/9+/NHuu8XGFdOSpRESedBm1Q6pxoa7a6tEuComFBmtC1CWWXLR9PQqPAKm+llg1tGMpXrZ3nEbLjt2azoj01lD14v9zR4JGA7mi74p+UHRDPJslFoOyCWJC9U4z3FpgVyIYDAbxCuv6ZCt9kvuOJ1aXUEMC+Ya26eOBDA9BwvR5S+PHZg1UTSDKqeuDR9BstQ9DBHJxE7LyHtQ/ksrJbqXaRuEGaEMAycR7RENW0/c5G0IXH+vVG7OgrsHeOHCeKrqDBhHTTd5EKhYCEz6Kf14Y3PbbyH7ykRSkYcUF111Najqh5PvALrrzenmVoiYH0C0tq7G6MmQNj95N/o+rC5d04yvdDBXq26hDnamP8hSm4e9dWPJ79oeSjl+ZN3M9DaVDI8tAQ/98Z5OySENMqqIWvosuf/M8Rxny6fLC+nLCe9MEMILsn2W8RqJ4FXBJmHtbHXudP94LwP0uaI6aS0srtQCA3QCJxGEri95dZgj/r6oyFBnBmKDTFR7oQPdrr9jVPAzO9sd+fZgBc9bvWQj2KD3zNIMjQ2VhTkRmEF6v0jmMZWZbdDuuTAZuOQO6nN7lw8Ttj0LrTCCLG+0lu0decJMFyAlzH3aAk1W9UPlB5xcepeyTHOjAgl8mZBCFZgUrSTmVcKSCYkYr7K1reUskWtavovP3lgSE16HdGxizW27q8Y/3cNtGPmG+a5FBItoubuPx/r0M5qT2Wkk5/vBS/I52FDGJbtEpff3zW+VZFCgED1oDdHkMUe9QjT6AXq05bFlXKE9Z3p/gZX6TAgAn3oZL2l0P5rD1Bd4bdwSeMCsW4Y0+vlqQpn/Z5/WZ7hAj3D36Ec2QDgXCStMFzmuTu9Zsy3a/p/OmSEP06LoDIYMTpgi6qCHrquyFuq3xNig3G6gFU3gK+M9DRMnYtV5htoRN56DzDdW399e2u8NzZATP9Z5ZHDN8qkdV6oaYXbWbVuoEz8MB3MQZe+JEQkBWuCORfl0yQofBC7zhzCCeiQCzwEI3rFQNTbPLjpv0prJnPaRr8moEBLltU+cmMJqytLdjRiCJ/w4IiA/X9XrsP6q+IkZmGAWL7K4KMTv2Ro4umFa84Zk8eob/yCyB9uvGok01MnjQ3K+RDLAc6GtCBHJItZzulRIwDWwXNUxxV+xFEkfYX45WcFnWLscwqUTe7iDZ+lC3bFVGYLobYWnVPsDE6MTIRmu0pDyyGgdpG7BcMnqAM7KlD8N7Px6HLTeF88XzFxJipkalsxBIxmh78lVETcvZuO13i3Me1CV8y06wok6DCBhZdKrJDADeGmiH10ODbitCc6nLqf6Fb3AIHV+aoshlNqNw7nnbfTn+VjkwK/IDsfYbcYBwHEGJU6zgZuSAMuNa3I2nD8nPEkgz7Px0KQ9wsEt3Tg1CmJH6fKEAn88OJMzGQ5vEwZHppqV8Q2p06QpT5twxAAfvm/fqRJwZ8CFlmkwPLoQIastSDQfzqM0J3VCf5mlMPVrFdxD2pUgCyWIUQ9PenK4G/ods2ruYt7v5FanYJlsXKGK4wwuP8j/2qhjbOG+ymlMYKnlr6e/WCkA46IeSr6Wgm8tNwCRzrFH5Fbpqnua77zeENEHLhtbGu8jQpIDGkEGL6RNAHoCuFrzBcdD0pSbim3BARzyV0W4wHDoduvm4Dl7sDTcgY3TJ5KdLvSo0EpAlmvL8mx3a+XQaHQEFaiRJuIQTzof7KL57u22CdhgLdpCsp1w3amVhunmpbwGQ84eUAYrYudN+se2evhlpfEHMqS1tVMdnBrBtU0N7q3i4lAGVCwXzT0nD+CxaOwo9HPL0xq2YV+sdh3thdOVNEr20TGO5XKsH8c+RCxpSCMP6Kwq25ZIRbeMgKC43i9OdQUZ87p4H7wOR/Xas0TYjzETo584Hj1iDGl2gVBISDpdyFiKkO9e0l8n2xgK67h4QEJzl/41cXLoASNH+K0GnaQZyRa81QcFIYwSQ6h2FKdvqPs0LO7u+iF9wRHZfWNVeUXntBWuCrD7845Kq+6X+MX+1V/ebscN5jX67Bqhy8melJ/UBp+OoToqQZqQuUVRuozGNP/OHMmHkHy1+TttXsYXrXIoGkR9qUBMMWXcD31rf90cMQ5ezDHfLs3dGsbYgE0ylLt7TaMtNhQbKePdV1yygUGt1ydPoivGJoMJ8OLoFfvUXpbp+8pVhdHatsYRHP5cte2adSzFHHMTxCJAz4NGFchNQ4bimHC3DziWKo+JmjO2R2gN7E7RtKaXHoyPKKqRp8UUhk0oq5S97pGZm2ptJx5DOoSayLMCNNFCY75PcNIDVRqZbRPF0oFuSvoyOImeto9tSVFKCd0h+bd9R3ediF1eAb9wmEtQoZXImjvZliRv4IHXkuhW/rZHDdmVgp05bAWL5nC+ep8YeujkNgZsBmyAUE5e0WALjUOeq9zRVQ1xC7ZrxgG4FDoZE7pXB6UbyBIgPKIE9tJUC9Jm1mA2/xZdKc8Oyqq21EbExHOl9X87b3B3uR76/9PkQgiiTcq0VHI3lYySlso0Wapref9eoGCpUz17FlRMVA2zHbQrK4LcIxcr07CFDaGn2PN0arVaJrO87qAHCy8xU+Fa0/KwJXC/knmRzGtsNgmcvAb7w+G/c6e7za7Jt7vCLNPekDfK4O2Kma2ma+qpZfywZ3r5bInvZA+jQI5lTJ3PB66Iyz3eCho/3SOSJK9Ep9LiCm6G4DMat7SHLPqWWOYwo3yF71DLsgmXTAguJaHxuwLuNBYvYmGNYL869rY8Zt2GQp+ouTwZ5RnjIlXPXaEhsJxoStyx/ku6PDaqp1meqf3iGmF8SNK50mAkFMINvXpgm/ken9Iy4o1R8wzu/mqgImQbNjv9jW6Q4H/FB8oYV3dwg7Hahg4jGgTc5NLJRLAeqapWm+q4TRYZAiOoyCZ6zv4gcX7Iot0lZMpJu4YjcwkQDnEJCzZByW4f7PINl47JC72FAAy6G3ICsADTzeRiexDoDwD9Zb7vmGO8urua3apeu5h/JixC7jGRKnpPzj1GrVJyC36/GM9xrkrPLdUlYpHQk3doyjclKaawvDkFlABa1r3Zq/T1RvJdiMnMuWUtywGZ/b2dZqUrIBTQrH5OUwnAbV5Mp8UEcYtX03jwyKKdLiCa3RjU0LheCaoOLxDKaRqZa16JNPCHqJeiha/c8DfnLTOeJT2fXWZJyuvryQIuanmz4k07xTv4yrWaKMIshiY/rRxrZ8M3SOxZk/c7KVCyvJsalk3CwPwPAu+V0uQbN/6hjmqpa8fZ75FYINe7H3YZuVt70Y3WOm1M/A3bz8iSpLQhWqdYQMGeFAgm3MREqcZBeWKZZV7tHql04Z1jMvu2pVEBEpdJ51Mp+Z1Hc2tjIDfwzbKq1wPZtb663PEJyeEwZnlyLONL3Vea7TNO6hUi2q47xnGpYQs6q02YE/zxF9u1lEk32Xp1tRMVM8yPqHLnnX5Mhv2F7gfaU+E9VylpYXmBDaZ5rHjC4NMR5ea9VPkM6GBRqzcU+35e9N4bIlm9w4UblCexRIWctA3W3YqOXSSpi3+9xp6RHtPF5m4e0wpr2RILZY+dDhjXwCU0zNM3VWISJkZ7jTAz2rald/7JdYgmGnl98+66PtdkYN8nwwANQo1lvQ/rM0I1S0kuBXWY+60rNVyILz4g61jYdmrU2m2jDhnWkaAgs+U6z7agpGmdwAhd20sLogKE19W+avvkZofTCNa5rWTiczzYgffGKz6XWaFzZlFoI4uGDQ4m8EzfmiZknsUy28LzTk0DX2jRrwtVHw7ld46QQMct5EzCkBWGQ/8TIxMPJfN8Ud2TfwnGf9cc5SkQrJXqN4TENDgKfDKSeeO7PTXxYZNEkg4fjCYJ/uzfhfdCEQu7HiMz8oE4NfekFkOX4WxricIzHUlCJgn/EVcRSPlqFeMJ+PW7Rb47JDSK2ykyg0kclYVAwy76dunwKbkzNO+hHPezw0ODQEXyzx5Pv6EE0oZTKRq/2nBy+3C99JWeKC4z+VoxlpLmvo0tM2AgICAgICAgPP8Ppq77fsct+27f4fcD/v+6p/Z1R99v2Wf7/uH9+3oivt9Mm+308r6iXm+36Yb+H2ku/bfV9v2e99n2m37eqHvt+1Gvs+3l37ek/9D09/4eoxPnWcP7fof/zfrHN+nZ/7fsFv2fY//VdLf+361C+n9iLv1b3/t9FC+r0Z750b08NUqqLDo13p+NQ79HVoN3GqGQAsQQGKL2xZ81rxxNPYC8HfcSmL6SbQhd0AwJPxIj3TOsKfo6PdPmFBajB/N7dw4S+6rwwFsYVgZohNf5VvXGip0V+4op3zOxfbt5jagr0D61rBYN+MeRAn4cuRw1TnnbDhYlxrYCDolj9hWSZLf/HospNeqoscajM1V4oCTl1+ZIssPoKgxuJ2fHiYZIdgFieE+ryLE2dllUYVEtugdqz+Lj3Naizyefy9171Hp8B3ChC1nXEE/ylONlZ9mjs1yNcl+GICzYAP2vpUavIku+yR9em45m9UuxYqvSa+c61M4p87EN4ZCZuRbFmwBTIk2vnUJEoBC1AqVa6XVAr24RLQnUr8ZYiwlzisYBh5i6O+tvdBMo/Q9xzYw+xluL4+X/iTETwvyZ5emp4qcHp9dqiZiHGSYNgltl88e074B0cKNp+o9S8uQP4Zrw83BoR+//zStpwS/12stfL69H3YNmDa88kR0x08TAhq4uHVI4SuNhugQYbARQudseGZsGE2rNLh8VWWvd8CNY1a6KDz6w7jblPPNesbbW5vZcG/JK01IsHWeUSw2x7fEftGtK9H0IuuY/YYSBuGJxB8MPOmCFaTRNJcGvRZhVgKebTe4Pcqr8R3uj1QNTD7m24N3mEpBZLryXC4R25ZvOYi5wkPV5TqrmE6RJPd6YDtqYJddC8XPnewg6zY1lJKFzshukv+BPSgFvkU7M/aBfYa/yGIX8cAydHEbtwB+CwQTC1hj4UuDy+dD+6VoQEW40oAUeHwKWGLlqgAPfHwTlkTxn8boqeyw3wt6i7gEaCRsLMy92alAqK7rnnGL6y378Ws6yEFg6eOQiNnLze8uj3qufB41YV6E8elZARqcZq6+l4kWMiTpKbhLErUw/q0foRkMSBTHnHmTV3mk9lqFAGVALYpf9/7aljksRzM5DT6TIGDr+/TdKx4iUaOaAwUyg1fDGZWRxyAP5/qD6ENgUEKCW6VbVzUJnN9SbvN/Akc4DhMfgGRgolnrw5eJwIvJrmmghJ/wiDnK5z73bmhwPrcfel5V8xC5+VWgxf1+M7sOdk/wrQzwfcx4H6tUWh1kOA4uU5/hthLa7EB5055GfgdihBoaqPZElpolQPi4CtyoOKiTpCEBFaIinMj8zRidZf9B+hHqwRMhhxp4qE0FtCGhABlAJPmZ6Ka8dUzLtce7buI01Zl9nlD6L2Eq+GW+9vmjzZ+yZAhgfeOVy0NMIgteCxl10EGPPejVUu5lzjIqOtgtpRoK0+XiLx6QmVr8xe47lNwHbN0gRQa3GGB529er9Kpr1W97uV57RjlToivXCNiQLVXZNAr0nLh3t2h9wdjHBRoSIFzV6LScbf71fNkozxX58e7zq8y0RkvPWIBNENpNCR55uxy+AMwepHFILqobK9EnKZhwkY6+lPyfkausZO6Q3tFdjZfvAFLmXO2zg5jDH5ZxAnIqQilZcTR7tlOex9phurtEXr46nOJatQ95fNVen3Pj8LLHnYghm/WE/PYfQwYq4dFSb8z6TwE2u7j8mndfoO/ff2asJ5SxUBF85ocQVL91UUDoeWAE59WsBNF6AJ2K757xgM1wjXiUzab0aZ76QloOQZRuctcT3rzInC47bziSk7uKYnFFYlzZR5s1Y8dB79SazR/lS/khqUnF9Y92/JXAOBMjddNgt6gDee6wh1QEikfQCulK4o4/Ybdm+wL61YAv3kszIkgJo5Y//LYAM977qHGx6B6PaHZR1/6EgScD7NNh7xIcpZ5umlQ6P9skjH1koFD8W4JDg1+IgBEIXSXAEsdF0mabEum1LeIZRQtAbmh+hYBhmegjfq0GnsfYZw4lYQ54oxmPwY+LJPsdSlApUY0nYhdnOK1JQ0DIakxm+pf2Y44YGOjzYuoDQHWIVzqWZhbJDPwbLDKw61JVYOBoZpQwCUTtOUl77+jxiYl6xHrMxXp0SgSs/24EIoaNU9pTIAD0aET+zdFLKQOXJ5t157SjnB9DA/KMbRcZUUadeX/XgG0HBJbZnLeVsH5Onczw0sqa6lSTh9iahbbxVBBCV1Tn34i4o+lixSek2mb0sdsPLbAUkZZJL3YTFmHM7CdwUVDs9glqvuxojeJ/DyRJe9l91cw7PcMYp+KxQHjow2X2QZYJN0Rp+v42M8ZaimDvItRKlGq6G6WaFmrjWG8MZHui7RTNoDcZSgaXjEVbtLYqcRyvBhnwvka957FMnnp+efpoUTNeNV2zEUxg6iD0zQtncClw5ijYIgtOXc+RUSBmlU9iydF2qtNentUaVCSk43iw4E0nwo7JAkLJI0VNSScOxN4e8zVuTR7MfwneqLqd37J06KM0fT3GX/t7Obk4ED93QtsC+p84qJzRWzVNUHHqHughYWBLMz4Dc/wL47t6RG1oNVYDR5r1NwPMGf4LNZo//CRUjFeUBUXTMvYq3ObPdje3DQmpeY9N9PVE0zT9+N4w1z3ZlQ4nrWXwu43rMMuVYQRJp1CYItZdSsYTbffyR6jGUU0XRelrao5We3M9uL+s8gp5/tSxjGiv8NW8OCIib260W6cn2iaEBmI79pD9XmoqrrC8LaUyWeff0K6vUALPY9c9WVTh5W0TawoMZLEai/kNr8ZPOjXA0Bb4jTjDy5ma8Qz8UOGatGC1vX4CY+KnHKWvZaaoNz03HhlP/mcng8EjyN7DD0zaRNcYBNvL8K6xoVvoc8Z6HmFpLpGAkPYrNmqM71kWTECjDmgIV6iTgIiwpg2VHrdL5FRt3/P0giNTxt7p74OLjXCFcyawsT2P2BFEqvB1dlTgzIUwEQjLQXIOSY11/RTEpbxsuyHdCglpgZXkrtWLJDeTVuiJgi8Thtssf4gsLH0Exvd+mdbgKbZ5rrW5QJ5sPJ5Vt7npbKESOUv+KA1j88ZJ9uUAl0x3bwFTS1zGrLO8svjLT5UVvndkBFKrQUstJmHrDMTuJjujfD8nNftAFXEaIh8wcbHACpYwo2d+upRDkhHaDp73VQq3wudZYBSK4DBIBF2K6erg/cFr0WHPC/BepleucMNihVogIiJrF1wNsD8UHcfW1jdF1N8Cusb70CCjsag0iVlAdlbRjkL3X8OZJ8opqT9I8TumJ+/NB6gU29TM/QppLCKG6+g5BH09HXMf6twAuNUEvkSkNOzwY9R5nv9BqDUktMg1+OXGN5Q9abAXW4RDhW+w7YVLTLU/OaMcT4+XprVSqLyqbL4knXiAmdctA8ar2HxnKMgRkdQcFJP1eaSXxY5hkTfIJkjpre9s3k64zxDSDnVToJDCLshfVcrVHTN1bwvPXKe1XvgyywE7A6APFidCx49joPBOnyu6ISrqW2RXCnqDXxlYrxVX+EDQkLGvD4yRZMSeOuob6BQ+bJoiNZi2RwOKe6RZukB5Vjvns2OgoS7FoHNZtnAr8tKgHP8wGjAiErLyG6SbCdGxEyfm3u5xquFucbUELaNFMuDMFagQUjMjgY9AqzK8wO7mAHLqRmnVIwobsuNPTfBJ7NSsd/rQRAy7zKJ5/px6psGvQVlgebGEAIm8DOqRZERZ2xEauaHKxGXcksS7xfoX4Lhpg/nB6KQvn9ZgWeI7Uw7LjySjGeDbDZ0kZWNtPWE4CT9FwdBGq+X/EGfTMgDxR7ekzwZ9wjuis1bb8VJtEZC1GzliMhecuS6CNmqyS5HKaNu4U3HkKuw80AfN0RY4ttgLitQrXjOhet7ITq75CEg9aW7+o5QqjrBpwimjeqOCs+xq7OX9B0tbelay7lwRI60nxj/Ltb7soXRoHBpTkndMvGre6JafeQ6OVWgaYR5ca+ojWP628akoQLkRUz1Wjb7jFDILDG2/1hUHlfVBRqIFi8R0yjhRlAm7m+OUojIP1JytvZl4fBkrkCcrSn822ThFkisvhpb+eE5sawxpuk9OZ3yjF43JMbaspMze1yW7cQnlr+NfG7QZB/fiUaLqOSr6HVa1q/wvDBSFlUan01sAlZ7AEvunx5wtjgc7rVwyuFu09QsHhnoprnj12/ki0ETIpdY3m5lmAZ8i5NmBj6tF5IWU0cHCeuIAapBznV41S9DszeetN6VXDxwj84zAGI5KRW0kzdBhXFBl5C9h5NI600E7MM/lK9tFldBUj2o3P2YwRlFXWCzrj00vqekKDPJ+eAJbDXqOBZdX2Qk3eMZIZMRIhrN+e2KhCapZHGUmoC6agC3kSrwXcSXCNHQtxsYoIhe4tQayotvRuXY9koyYm2BoPhuEJcZLe9wKOAJ/nJ3py0Fs25vvetAwHm8DEtTlMbCys+g3S+eVp8GOcIFoSF4aBR7sYuhASxG2Oi1CcDak16cTKzr89E3gqfgdtmy90++NloiMplR3wZUsYP8sy7vhsT3bVYZAJ33JiTTcCL73nJisrMStg4Snu86x8GHOysb6V3IBnflImnC148ZX4gCPatNk0OprJ2BzWQA5pKCNFKfpp9v5n7+HWahg3sWYmdNrjRUBaeaPYJKqExGTVLJdAzqCtSn+E77RWIjkT3yR8U6715JXKR6qFQF+8QJi5xk0k77/a2Hjq9y7Vf7AjlOc8FHovTzBi48EqqlB61v+jFFQdY06+c4+hYQ3T1BIdQqImivgWHXYFao4s1y5q+QMH74Vv7a3aH6zlkrdvC0zP2WyFF7UlI+8cHnD5HRfKgqkkhYOhM4itj2JAMDfH+90WPIQXrT9piVQBj9jeqGCYm1ToJWn5hfr2V7F2mZd4Vj1HqOqOLYlh517njYapEMOMF+zqj8MPDxjIL7H0KqBMrWqUXXhc8HTnJztcZnktdeuthSWfH9fDHNW7FIWM7hvLi8v7LvAidv+hfLTSdi4Nssd6xFIAdBysWLCLnotv6fiauT/iRVONSARN9p6TWGpJroJak/jk/Ttx87fnaAIsv3xXOxkQsfctArI6iKqH88go/pBD4BhHF98Re+WhgvGUDz8j5kFbM5ZY1ORKWRKNUjXvydb5L9bLpdZU5c34NKSjyF2JrB3nx1ZBEs9rshg5l+zEBFiDM8149jf7Nzih8qNwgvI3qQbJFLD0eCkreK+WkzAnR0n4g5TqhkCLS+gfr48gQzpmlLhjS2z67tJKJa6f+W+JB288r+f+HZVDlsyCm6F+KnL8LVkeoWY5aqIjqGxusl20XgH4yBs9cdYi6WC5GqJQZTTUepgw/LGxwjq4TFP35npNSnGmuQ8bJrxRdZ0flHLAOwv9e+JoIMM9mjXwELKVA7CfBhMrL3XAa44vL7FIiKOyVAxJIIzZh8UQdkINTPJnbFaAQ9wry5OzcEGeA1+7+t/a5CWl/qnDao36pGAKstth/MvCRYuUPnAqiRlnRjQx4SgG+pU8DkLEBWV0q/t4iWGz+xZi1oB7ORYnfn3J4wmXxhwps5UNsna+XoJazN6X0J8ay1JYlXbUqfcvTrYkYcT/1HfFGj+JZTMw6pHNizmaLKK7CW4imMza7laNKJBAHRhtJLB+PdejW6g92zsFXI9fscH/BFnL7d/qM3KsrPO642gLiQO+7ySObM7On4u8T4fXCD1A/aVsKkR9NRRDLzZMF+l57NolgJR/tL4vXKU9fiYFiizN8PopdbtMO0/I4X1BjlyQALON7BflFZSY9jzsIAtNc7XMFMbtsZ3ycxqDbgYP7hjb1Ino+JuY7YoU5DHqDB6f2sn8MxqQc+rGvtCsjzPPwr4n3xu2BwkGKC12HjsKTkSDDD7Ldhl1sTaQ3sS05H5q1a6IL1Dn81nSCM97WSTE/T6H+ze3autyCH2fd5StSfTJbMWFfn8drdazFTBu3X9FxJ3DhkLIVxmTgYiqBKwvnVdXIwAH+Impg+m7dIzaTX09RyR89saDDAc9/Wi/bbimS3LmbhlmWJoSouZhYMH3dYLMSfE0rzkDfKnAuFP8LuXTqjUMVXmLtO9JtJzPwKH28mpS9TfS/eTsycdgG5JRPIhoN0x5XrpdXuqw3QXvwqRe80iRDOPAIlNMlv1FCwGRWlphdaw/r+FshG9DMtteODrwxwdiuYUlTnWimV/CaHTJbnQBabJ0BTIFncItlzi/a7Bn+x2fFvunvVM5+qrSmCo74Ufp/MXNuufc+lltzLWNdXjRVdvtpRCy+lDu9YWRP9rxOr5as3zH+wI1XKbYwcrA/828Gy//PjiAygRPf8sLFfTevQCI7hIhHpYn5GWnuduW6LzOC4d06On1YUUFU3Hr9SN3KG17oh5MrVx7idBG0XfKqvssvdcH4P5YAnvaInKYNoInE51+rbksAd0NRYorsXgRFCVXOQbj1Js9aNLPUqS8i0cFUPkynTYGa/nOoG9Bd0yzo6Nz+ksBou10wJaIfAIr7L8r4NizYjtquhOpqLYidRTtsXAQCdOcj+kBUQlAb6NOtlwvcdf/BWJisFffuScTWfmH02QzYrV6H/doN8Zexsuc5XaRWJvXd7vS9nBIuEdYm8mBL6MJNVwndO3WwOzHNRiOkg/mCN9uox1DLZ9921yIOQfbe0NaRbuTgwfcpQOJZGnuNJ3nT5Bo8w0nBUpN0ka3SppfCXcU9fGOqojyjE5SebD5SyP4PzzkLkdiLcLlxyXJmDmIStTlnfG+WiXc6H58RhYjrG7We8SIODfpIk+e/LnHwInCb6/QRdZbXRl8xo2N1eARZzJhUJe1bXJ679qwHhiHbcnfjSzKVDlzuRh5Zeur90VOYKp1tm6lvP6Agr1kN+XoIuxigD6Ugi2s/AClozK75VNDJ3Dt9DPYjDMgvrrhCvVQWQwGPgwt/6/JFtwcnr8T2U9hET/G31KA8G/8dyVtVVV4OI/HPmUthjOLs4VKXNWO51BS2RWedLGuqU8KYRZaSig5NjjYkntOSp1tNHZ9NRWwIj0c6kO/JveoG1saRRuEa5cYcIE3AhlecqpIQGwdYL8IuGwVucLMQujnc0cHFPq7uTLNe1FXwThnMH5TaQujUMxFc7697dKVEmBP3RwBT4XrwSnoj7+1GcqbxV57vCyq9wqcmFVitk+QkWd8eIHhNNWBtPyf/LgRzO2Z5Jb/nN0CPB6hkGjpWjdPZwMLAYCiPLLsI2/pVHEGIrWjw7mlkAcxaI6uU1BZivuD7kCJFrJZC2X6ZGdJ3HmRMyJhD7wdT5UtzITpfaAjrg4dKOFxnTrLftoDQAR7cMA0zgIt6HUcWqvPwJOmF9wqXVFBqXmwMi8Q7Nnx5SHBvIlUm9oVfmKA2L5qDf+7Ev/ekaLJ+vxZWPmptYMs15hGRLezyhFbWAOhpCFMyIaNK8PQBCZv1+Bv1TDaXPf3KdcX1zYvyq8x1aMJ4UzHdfYXVZz/yYtw4n3x/603oi02ydP27O89QOvIZV8MBUCMcs3qU3y569eK2SGc7m63YHkN+MlhytvdeR/D/uEqfr0hivcCX1wKhEIGSZY33kS+0/2MljJzNl6iyrJ21/fkGtFrdvJrF+no4zE8SzeO8W+eHc6f+GfihFqOCa+hzEzxCQn9C06s6qr02w4+7fY0W0pT0GLUrx7XgqB+hvHovuNZt/wSyrRtYJP4KELWa+RBVN+DYgZxrKXBbvnKWuerqZHzbEU2VSWAsy7LBJYBq3yPIWHftC3QbsPfbj2XsCF+n3+Co6KFo0bIcsCh/Q/4eRU0oJI0mBW+6jTtIdxI0SRtzVLZdGpiv23rr53WAIa5JHpPm2lKElzu6ZVPn0w44sOx5AAvPigJgp37O97Td8FRcOwOqvZfyXnowHJqjEGwrSDUAedyP5fapda/oWkTBImeHDXeS/ClZEo0ReQXKnElGKVVdMwqNyrmV9xQZs2dgQm6Zh9dp7Kf5fVNbTPEbcYlhWaV3EYa5NLEnngngAoU7y6qlK3CiRfzBvm1fjUC4aonWHqrP1CmVSHH9yJU+SPaw9AWOL66aGtnGjlH25UgB5iBswrvanTNbQKUNwQGeAg1Y6oDHy2MUeBZ7prcsJbFjTpeC3kH5Sy48r4cfNW4zMZLD7E0XH0Ncq4ac/0B7hrDVNO5o0NbaWyDXLV73CXd4nkFXafkQoaKXB+8udrJGNH4H72/V0/ohVpoozg3yBXhoFQ5up9YujXLGtzYfL8ukulVDDrk8eZC1YE2akGzs7sbcs0D89aBYtXb9O9RmIoul2Sj4ZY3+3AGqX7fZSs7gcCMV7gHOXDbZ23EKmMjl57UjFcRA886w1fMY0iA6B6iatSBf8YxJQVihxAalT84exGITN+VKte28PzUTUEDOnfY0Nc7TVZQiV9izgMpy9nh3aDDOJEoEr3O2Ex0DeaTS+un4EmluQUZOm56clmY3CGye5rN7WzK5tJdp12o4F3+AOzl+6UXxTVGv7NzyeJlOFEkcJ/A5EIzVbrM7vuHY6/ByYAcqjRZMorrK4G19trBdTMG3nskmfTRzFFdk0+dl3DzKKSZrg8P5uGuVIAZxqYvbh0uzTRoFVcUI1smVHwK4U1pH03+MXej26+MetSpT09FEah+eBMQwXmURSyytrL7tFtqKNd+L5Akw2ACu4eCOC+oJlxUV2yXdGZgSvB/Uirvk8mkZPz8TMrGpPilnMELCfOeJgRQ0WCdzzqQneb1vpYnzQlPhv1kFWmGl+656Jy2iZrLSTwBfr8fK9xW7AdLcGHKtHW8yaensdRCt36ooNSp0SsPGKd6ZT5Miqdx73UzJ0PQ4eL4T8PAYJ7aoXyZ1qvBY2O7xCdkuPb3quog1CV/mhWuymnKsNEfeIzQjy+vsJlFT9I1QFTY+JskwUT2JiC2U3vwTOHx11cxt7tjHHrvrtAZbUVkAzyLrmbNKA1r1O3zF1isYlILAxLwd26s/XtfYUH32V3j5F9BdusFmWtecDPSeTKp3/WSFvWeCw5ObdJ2uNHerx6YQbYwO/Wa7zXqGKV6TcgF+1mxmL2yKacm0DKZAhjrsGAga+WpidexhdswhAo+4t9O+1Fs/jgd7oLfPX2V4/5f91xVnuRaishP/NITrZ5NwS1WV4jw8Gf1tgtXOATyVXmUlDyLCDVem4CzVyJGpP3qDOBcxt7IEA37eoFyFJI6j4pU0fmAVuY5phHT52PqSrA7hPFccM3xzBtSv75+SGQ1GAmHtLYRdKHuBGcweXjW9yCyNlXz5cMiugDNxC7qkVNuwmIo3uYKXR/+JHURFNVMXSPk4vXZa7lVdAl+x5vTIUzzWCaSb3HYxKto/o2o3sCAo78frT0y+51oScBav59767CqRri3YOFvShLprF8jh0AthMRMyyqFGTN9jd7cmQMEmHlp0KGC999OrumIckn/SVXaISIbBTbgjquGUfxVOhjm6ynz8vR6ptLtZ03/4Nwebekx98qXdIiH/OntGrIpn+A/rl8pGdHy1LkFB+VJXgaI87xUSohwyaQE6or68hswth1gzTz5iS9wS03CbCspNEbHzVJkLxmbkU8HwDMBQH4JScAm9fjaAmxvAzFM8AoWRq+OWWk3ak6xFMiN4inUYu92weMDhx8jDYoWbuFhGyJxwBPOPvsIAdQ8vu4uXrPumJqqLQfkhlKJsu+L8xCKUCSmPXjfB3FJSrTs31SuezlaeUtb6axS/z/YfLIlEnT7ISYW8foLFbNVv1fuKfA3B8xm36erT0niosqXVxHngQJ0g0aZN0bIhxFfQ0vU3vN2nEkWDk/1WQeO/NB6hT6DZbKvrniejNwV/q04kJXe5fcTjY+ub34nCarauOCWC2ctIKv0QnWtJukyKVobkdOYp1fi3CU7l2tv4l1Ya5QVPukKONxg5UqnINOJhd9lIbeVKX9ZvL7Vs0QVOEuqBgFL5jm4ntADME0qVPqonDNniVTL3tkD/8HOa3eLDRrQnp6WgiCMoDlaNnMmxvAI22m4W4MWupIcLBi+z6xFVj2jD2shkmA/Zd2llGYzh4XjJrNoBAGcjlkifEwNBkB3IKUrOmEZ9I5DFyIedoTnHxT+KjuSMiwnjnQxYezDnxOAI+RtFeuMOanUd7N00DlX7wpI2pCaXrxofPzOdxuAsHr38hcNlxpMy6/Sn/pozvbhp65tya1S0cn1wFZ7f61C4Own/3oZtTO2BsTNDxw64YKjm2M7ZAFDolWiBdfjyGJvchi13dPRhxgXZakaa3qB83brCKhB6+w+Ed+3EnLWSIhTnCOspreIIbXazIccOiJtSzshCFOQ0CqaMrGyF+AezO+ameRsh4P1v8vk8PVV3mpRU6bcpMD2XogbEJIPjjamD4e2nfGz5+oMf0/dDoFHdFn+15K7cTnl9vJ93zq5Thm4hmMjFi0PfRrc64vIaNZyRkJzTlL1nCZRdRItig2MP8chsJs8uuC87WJvwIyRX6wNXIjHavPsx6ybOzq5TnWnXz5jJZ+EXkM0hMQyWJrTNeg0HRnCl1zWA6A3dvo10VQbQ0iPaJpiNu9Z3oDO0wy2uYuDgpDfR413C+mjYUbKccajEUCCOk6Qj++gURLtYoCw0/fC2baX8ltVm1xfpUyQvchGr8fsWqaK8xWml/ao+Ci6nJRmplqi+us8UFxKo9Ql0kJgDqkxD8qo1e5TCA+MpLPWnFQLDHRil+/iSnMFADeoXOUtf3PaLAUaOYNuGWUHcCqjANrZDrD+KDtQAon4ZQDYkQ1AwEFFOhY4yiw0r/vRMjEPeNS+KtWk/pvEQCUDsGHOVhswctW1u59Q7wl7tdp0kcMkDaCWdgLJX3t/rBpmULIEx9OhTSbGtgQ6r1JG7hAuopcQtLEDhIflASin2INMLGRHzoLpWMjXP2usLv3LK/WomuDWxEjzxh+KWhfeZUV0GfNcmQdvkA74oCsCffA+cm2nKUw0MnXC1cJmbPgpXpnDvutAxDpSBGWCBOcRrYl9Sd+nGYfoIOsOt9uI72AV0og5Yv2rTMSLQGWIaqnS2A6XXjRSKpxY1X6VSkpVvv/SAZeHQuB14oDA8JyzV5XMOMPUqgCuCYox5DokH/TTxBbhbkJi6zCl6fooqDNqhBckySomeQTNNV9qGhk9EUQwz/UF86x9mOww5w8DbpsyJkzeaVXJRdgumlTSKllpqrNlvkHc3eKiZee5sg0zvbp9kEXRZKV11w6ocCMTbe3TPXLT7QiIKWfvTY57VzwX/F0K8ZU1inIp3hunVCwYvU3K0YhDid/jKlQ3phqtvi4iPsDEIldSdA3VIlb1DBl6REnO4q3dXQjtCRn6yCa/RcBLSyt7OH/EzpfKsNGlY3nPjj7S20WGj1DWxSFOh5bmKkt0NhcFtJt8LRmKDI5HdbVzCejc4C/XLRNYliIsxJdI/Yy2uQ5p9ikmJpQaCj7nLgPakhYWHFFburaeUZW4RN+puN3xII6Q22mvMR6/fDmQyPX5huXgXaxIXwmi4in3sRA2Ivs6ZrCT28Icl8XrqGh/Lv1u8VlYjNFlAftPmnL6SF4SVJjypzX2DxJWoW5yA8kQeHTUZouH5txh1QbexUjnir8bBKdinnCVgEMlJJiDQsVIgzHvHYHogsI/DFING8UkaXQW0ogMWSFDEAZvpPJATSI5WPP0kExGSpO5IjUFtK3dF8vr9ptTksdVyG8muw7tMe/3PofAoFba2112yrT/qGBPrvZ08CION1mCxu6oyJC1nqteqW0JX9sTuEYwGSjANOOMWpIyBd5zICoqESfzX98lMDQishYFEyeCed420Fk2TZVRxouygqikLxOPGJHqe/LcVW4eXUnrURua7mfSD3QPa+A3ZR0SisLFFw4NniOLPUNDGHG+YI7TfesOOnNmp1CwZdxzU3dobiNqIx7/yVA2MBWe3uVvy1vj/c+j5ivLZUNDApJ7TfqAsOZaUfNkaFljttXoVLMMgQbzI0u2He0hOZQ4W1qVkFVz0qyTjmsWRUpH0Xfvn85OHHVVfeZgSFnOH5Fn+zvVdb1vg7nnS5dDVfYbZ8rmycRiGs8sHAqG24fmjDlb2UReWQ7AgkdZxNFgxTbtfgF3uy0QWGHEnXKFCxl8TaLKaLrmc51XqbKousyg+a9uZ3/dOhGIlTrKIeIbVOIuiJYwL87n7238qxxUhKLNMFw1YPOrVJplzbACLwLJCxEdcoxScnEV9BXUB+61pqHi0zM75SZG5VubZKYiUGTonB4HkglP7TWxiUVFmrJrAjSXisxkpIeLCiG7kNnkJ3cGQGbntvx1YJg/Ua6kFBjBbeqWh8bV2aRipk1aiv+E+ac2tq+Kxdl5vu7/xNYap3M2sWIfOqDPchAw73nJRNG5viVhXLSdNYYBvPX6fm57pbR21mkq1dZ1sKfNqbtrOFcB8/h11H1MuaZO7KGIc3Lpj4PWjYAgKE5BLz5JeoUKqaV/pLrQgOsyXOT/O5uvC0OUGpGQ8uwWmE5VkBwp8TjrRJ/UB0GyjXWwVxP7/sspaiy708JvICGU0Su3m6GAOSTqeRZmZmUB4Z1StZeGVyS6B7avzxJEhDHpkeSDoNU4hANg1pODRa0t0ysw6LNgTu/Z8CSggkGixyD9nd39QVGEDq9mcPgdl2JR8Ypl57ddt5jabzaTxlQdMMWbYDtqgxbevI+nnJtRm2/0OxZeHZm2MP7qX/ob9TJ4079vcCDA5JKnSQC0ep7ipoAPSBoWs1lXDVv2InbrGnzIyNeJgy8iUFMrR6H6zA38L4f33+qJ1joBGtTMFUGpgWhr7z3t/75l8Hmq5o7d0jL48rswC/goixalGl7V676Rtmy5FPz+mw/OEzH7QHRE5+BwCwVUY9NVqTAFqy4qifTVHtBFIIbeKGx2D2d0HYY6gOoSkuA8rbh/05RuNiu46omjSpaVPUC5UvO10KPjY/BqqOuP4SmXDUydUQCWxy+6rLAluHqYWZJr/DF7hCvJLv7ri++g750tBWR6J0K6aDMwz8Oh7WhF6b+B9otpN0NoChv2NeTJUmyalajT4jKp2suyItQ2cNExIaI9pdK1o5iz8JaV7Oa+VrGQY77XvU6q7rJBvfKM/ZwCToUrOCnH/mysPMbbyxwWMxlqBn8+PriB2AYbJqVdOWHGs/MeDf0v5Ul/UxCC/IE0unIe6I7RIN3NVRkbPZF83k+j2jtqRE53wPCmMtYco733MoUhzRKpWMpaUOpR+QvjFOa3s9l8ggjAa47jU5fvQme+0sA+5H7GNjgibCsk6HAUZNhHAFOvGCi9OyCGXp9GBvq4XtCId5nB4pT6EfQfcUHAtchCURJXrtWZ7iqjzfy05kOnBLoVBmLF9rgUthZ54Ug/I0fhRBzD4uCHs7q8YfiyU60o9pxDWUGHNfDDplrtsa6NgfZF2D5EhIoo0qcIiBRqQqEHDu6cmA50ZJpFnViwLURMLqAazU+nkVrkpFQBEc5H7CkUTV2VNMqGbZQxEi8iCE/wD8YAHTzVHDiaABsbX7bqYtAra486j8liJOBesMy2zNtML5FWYg+z/CVcTjEJiOCKGzq03w4JypBcU1gR36T55AfS3bsnavhHPUrcoYDlEJK4Ay3HadaGpZirTrEbQbSi+BW3B8cPM8MkN6hlAUWZju2Gc4W6pzJ/1J+WQyC7+rRJJQEuKgs/RTeAvFn6po1EpcyL5sRmR34MRVY/z6n6kilTfXjy9p04uP9U2WfURS0H6NMp+AjkOFuA/VXGxbkRhuLWkv6rPdyux7GDp2rvlzexSILtHrSwGNKCYMsR6Buyj+a6wv/L1BKUf9lOUM9wFcRl+88QCQhTSDhgtpqvQYiW3nbe2hroYChzF/vucBI8q233nCO9OAGmBjrQOgusngXcbrqp6Hju7gZB4ro7vRU6xwVwoMRNIYlvke/ifzq1JfQ0kxKI7WnRUV1gz3hfANDmhnZCtdT+ynLr2E0pmKQrYFGKGSvP4LEnGTcNUnwoh1NIH3mrJ7TQoY3lxAdUMlxZhAEGQHeTklMvu0kwMp3zc8tfk5Gux17FZpVa/kaZVsLj5obkXzLZNCrh9bcJ6xixI4q83uH/l1IiOyc1aXQrBQVY9f9wVZOpNzjmcWyWYEswloY4uufid9A/PZim0XpTocRbmRKMiJr7Xozc6VY64P2zN+rQJwdsCaFVGDjNUSlzxwZ8eT571Ze7dEetFLtyMsp3k6aFj0YRab85ylxeF5ESBkjCuHE6Ifj4vPFIcNOJaYfjnCdIkLqcgv3xk2Drii198/zfWQrjBbwCieIztqVPWCE7ljey8AhIVU7ovrvdjEY4f0UUm9gOJ89+N8UxIYfiEwbdRKUIr1t2HCFCj5HFGcPhqzifuySZcgbaX/ev+7MJbI/YCXFPAnllRiBuSKkYY6NNRCkvko6HM8AN59ItWASrLUJ1UaOY3CuGZssH8XR73lA/I4vrHHRZojxfTxeqJsTG0f1bZd5Iso3rTIP29KncIaCOLGnW2Xip9W9vBKhFnzjmc910tlT7v09qGgI/GxM1dpS2qJErKuTo5uuphyOcMzRmPUUtJlB6U5OEkN+GIBiByPIW46e3fV9yODQ1VrVkqFqZBZpYwxy9JCHPXh+fhhhNSWiYZt5auTOAEPpojv+sOXKuP91yox1OJQO0T6bJLhUcZNef1Pp80mt+w5+A2UforoWTj0mbdiPt9alHkbOhD4hN3pNCJ8XArRS6KFJS0+GP+5wUi0U/JuXKrlgaiacRIN0RshZ7KU4M/Le3Yb4kOZCuQdwXqDhuzciVACaJX9GeISnmdrIW29SvHx/u0L/N/Yr5PB8REXf4xNNaQLxQm+kioYEXvVdF+7qoi58or79MvZKMZbgD2NMbe+uuDVW9WpXE7+UaeYiHWgKuouAxRcFq0RYuRVpelTBqPRhx+bvqSgK21AYy4QpLCGTva4TjHbaQTRwEKbEoYD27bQN91g/4ixwqpeoX3AuWcmlAERppp7+ShqUtCEISm4DtKMWSLAFCp2f3p7RU80ekYxRDHrsMCBPFAerZbbRvmvsdzvimQxpW0sDD4dvZFsyt2DBfmyiUDQWA2jmqhoiUNv1MyuT7Oo5TmRiKIeYtDazsX0PpQ+HfanEcPxyDhCzjin8CJutMvpqv9iwAPGRcZUuYLxaxTYVfvfPe5oft9/4VRmc42uvDeYb+k684QycXn22Z920hBl4HqrQp95jXirhalbFMxMP9Xq9mwtZwUMZBvJFMfe2xiP4+2NQxaXpivedG38RMWTTtYXzE7G6RPc5g4ENv7UXnq166CvYx/NYp0su3nl6sCvlE2WSuxMW0yxH39Z1NQRVE77Dp27SUQEj5sqVTjszIANjQ9uC7eWCdFPq+uVya4cIgQKar4Z/E/MJHeMNGGLiQcb6NcvL26fWMRCej7S3vZYQvMELt1LxW3+SXvQdzWYA5MPb4x2SQ3WKeEn3vlRk1WPD7mIm4Xkr4knxyeDr4fHcvU6vQdk/o23JqsqqeEdnr8FTU11xvlVF0QI9LuLmimSCZJoCLmiaU+F1vj/yAM8OgpCBL6OOhLkSegUtCa+my9gl+Vz+9PfwyYogbEWRlKeT/P23uBNl9lf55y1uUsre8AqAWBj/J6ksZrUylVHegNwGmyfo3IfPfu0gC18rzmuU+rOKmbxeugacQ4r3ohqveP9OiORGAif1eeZ7ExVxOCcSEVRdVIm6ZrmcuzwYwMjzuvecuqMl8QI1w2ncIJp0RM6Et7z7NCwM0jZ+1iqu8xz7OKfy85xW2AYKNXaFqBQG0DCnmrPpJPR3bbMydPzEgmCJJhHoRraLqS8Rphbg4o17Lw37EN5A5oc+iGNx5EG0AvgS3J/4eQwDvcxO2I3iyu0kiyFz5I8ERcg4HGL0EOXk+C7tdSsvwmINCseEZhtV2QaK4G80oEQzSOcXb+eu5JfjKevbQNcu6S22moo8KVhdzAUlq28vV99rA1c77W/hhF+yJw5Wg84uyKKwidkKITcc7u6LEUqYC3UuyO7Yv+87nxToMpH9jcqW59USTcxdab1N+mMmAHU/j4mkX03SgsqDtcIGyzXcE2UHoCQKDcVl5U3VCGcmvqKRN7U15CfkMYIJ8pUFIEwbgXxhuvbezn4m0+VTq2x3QSZmzLNskLmB/K5trBBMDx2hCyae6kF+BSjdM9e+9xhbbHE20AnhFRUeZW/+vl1+jnXOBsqZo/pJWLAJB8mUqhFtozP5YsnqBPfV6pdewzETZLpdy7V8cGIz14pmSDQcckZUjNEGkft1iarL0otqY2Asg6x0kznTpA89SCo1B1EI3c5cKKg3wnRejrMGG7d8zHPkil8XPHKAutxpuo5PFJlmUuSwDl+mkfKTokFh1pEFg7drK/0dDokaX5Dk+fbeK8rtjyrqf5itH7vgSYfhBpEzyXdiiBcaFXJZbR2ZpLzGeG0hQg51md5335YfUW4IRUJIqNegtdajfG2xJMdm7xdlH5tR7d8gXUmB9nBievk25bz+ZBr+4BwGRobfkhm9vrJPFdOEROmVUtAusG5aUI0TrZCgd+soU2y5boiBxoqT02+K3gzSrfWhIFofIVjLmtXl1VsN2jV2JTSkPPUeOlUBIa/QPrMnU/8EycqtSBsSj7zkpmcnJ5DcWsUSKh56J+1yRSqWzyCrPYdnPVYRVVPI8eREfNHj/RmXRsRehifJV/9w2rL6fZuOb7g4ZTzfIlynDpJZOHux54NK6yCNPFQFWbPRS0VCwxZl+5z3BSIOwQT38YinA6btM4hY265/B/sGMxuo9+EcR9It2O/IsJYXIcKuMj+uJ3wGc46H/1GFjVRPeN+L+3KffJ43L4dKCbb2LvFqnPo6WMBypUbmWYmKxCxZvKq2wpJBwYdImQfHeNuwDRkEZ0qtcOljcjQClXi+1uJedjph+c8WfZluB6CWhK7OMMEoezTvRdZwe5Xkwxe+frcRiYQUkWXZpBIpq++lpb4j2mraVB559bNe/Vh/aV95RlNciUVsVSxd9zg4eOAXBlo7ariJwuJ8dwIoYgicEgASPGkbQrdsc5C9PUGaK8Jy3snevWmwR7v8qJtK+pulEr84hON3Yk8Z8nV3EiBYMUJe7u+D+u4XoNJ9owMSjdRI9Je1pvrgVFpeH+ySw0k8N1NITImYP2iQQnRt54Cr/JH2EjsTLE/ZTiRYHOwT9udhx0P45dq1WhQor0P8eM6J03mEW0IZ46UcBfPVnHm/hVkg/HhEVGqQ2TCugM7Qma+udBV2Oiu2GUCuVrxcsRv6tZouQZ9ayA0GvhYBECSfvUcP25MKm1Nbve5dcsVnHuHcM1GsM0AEhR+iEISfytGBYdg6ofn/dvz/Mapmq9BHBjRpzyhRIOodEMDQQ/fAGOWfYfDZmSIcUsyhgbv8S4ZWBAtsTBBqycIvPR266vGpIkrHuE29sFfMit91Mc6bd+mACZ5QvkN8xKwhbPcNsNCgykLkgxjSm8PTxSXG5a1p+dlRlb0t7UG0LgevUb4I+yuIN6umDhMUmRVxrVf/VV6Z4Qa6PCKYWslsOrvgyPivHh4SvqXo4osztSBY2QClquH/Dpk9SAQ5Z6LQ7gRfhpSchfCdUCucI4h1XRHP0660K5kvaB77RSXcbStUXAoNUJ5JBYMW2+0RrppeLz7Sut6PxImcQX9ETd6IHnfcg2m8ATuPENmthw7oyDolIw94rKtz6wqSBAjIYzamlfRruyfr7Xbt3YHU9Df3tBmcs7BRYFbzjLkyMVYL5lH01PaqhWYEyuaGB2ieefqzUX+n08NfGHWhF1lzkvSshChtJBMhewREYf7LZBr7+7Px76rD3lIED2enDHH9dicmyDDhDlPgAnud/aSi/D87qp4a0ZAh2Y6DBiClNICmeceamEXW3W/tuMc4LxTDXlpQstePE+88J0IBFiXiYa1Sx4DCyNIQA2j/bmOKyCzS3s+7BLlhvEKLOX4NhPJxAkktA12aIEKfQJGd1C3l5f7CBADKeO5FaYeqlZVjOwmAEXe/5NR9y36lKTY++NwqESclK/Y5WsuBdAXquGfxpuOODGiCQ8u9y/kDuzDLPOl+lPaNWeeOnGCsqWA8WbnQDO6C2x90fje1S1OuySJ4DlIZVh6YcxWyDlOww6kxCZxYSAwOhUU8hRnFp7G7jyyRCth3sSFu8lP5fIC5rgeZgnEasggyIZUTlpR8t/OlzNstKeSLzr9IjWnswWTA/ukBFgiPCdlqom/xrf6KFvnxY9ENjYbe1zxhuiYQgvMHvSoEGnLDrkVCM16ByidnFAlPbkMcXjGvzWpPAKySUhYTd2QupekvHaRk4u2Ya2SUqN17aTZ5+0dbDHEAEzZhSgRuAoid8rhFXKda3s1JGVmjWrZQ2PpdSPZpnxwI/eIo11r7iNFrFwfCOxzoHU2eIqf4OfefCZFY0pj2xtSmWPJDNDGFrwuZU4/16e8WoN/Ye1Bs6vHnUatxCQs9X96vtGNnOhGE+7yOmmNoWlAQlcpdtYHsQ6mSygZNxyofOv26J0tKMLYqJEIT5Se1OtNWRwcLA2i1hHQE5M2cjXnbUyolN1JxrQ51WNyGpORdFdfHIui3y5Hu18okSUjOaxYJU3C4mZsZ2lRrDoySEf12CyZ7zWw4zgzRiyIuumgWkr89sesyH2EAtxVskhsZnUfvxMovyKek9CYKHELVyMunYKNP5y5QTV1ChGHRUB0UlemKEDLHCYaz+RzfJj2pHqOPVdPwp68asZsdkMRnf0QrBo96yI+srNypu68mY44Y/yBJOR+TqcRfmsqNYXyIjzQdAqSfnGYCJC0kXGebEApTPcRqhz5L0t3vi3cUrX66GqQYWIOlPQOFFPwLgVYzgm2+eoyZOrMBvCebT7gjv9Re1tec6am/wPn+aKW/xto4004kGJY3Blmwm3iFJyyEeJ7v+nWYekk/u78AjpgLPT551jh/6Tox67TCvdLL5dde9CAzWsYfiFb2lxYQ7vR+R/5m5gepktYMu6EjE9Qne0iUpD+ZZNZOGnNnOySLYv2KQfKlclpfK8B3ixXu73shZYpomSQX+1LaHmRIEVqRHxw4eQcwL+B2frUdVskFqoch9uTQXebAgoDLDCRuNwHASKALfGTw2gfNaKXxO1S2VLRtetqh/TEZzIWdHKsXdcFh+Atxa025yOSUqF5ti57b4KN+hf51mUKoQHBefb6eQkTo28fMlkCi44lGq01tOZts5zanrUuPrYF8TED2Af95GAbq7/ymQCBsO+B+WLLUrhDlkQ/epYeX+QWL0cLueOLtxzFh6/SuXLY1LK1uSJgBg4zg7kJyny9bO6atiL/P20vxlaEf/f70cpjoYw/Zp7EX/t96SVZ4b/qUMcs/YoegF/HlhtF3hTlxiQlTo7hX4OFBOBrH8MIKK0V3D8mMt7P0IVdbIwE+YpX8qgTnanZ6M/g7d+8+qZLaP7PuvdQ9k6DJSHD4aga+E+lAxyYVm55GRI9yUBGsFXTa7Nnf59EzwO/9xvpTnjNmjwq8C7m76hv/Y3vofKSa07oNNyWYbH/tqiiZrZaSswZazhX0xxL/GFkXpQPbrqoQNdI8lvIXnLz6qCxHjLJDmmYyB0HmsGOqJCOVEOgF+U9H3rCbVpPVen1bOSQgFM8J2g+zfGSsft7+04eQmGm6DwXYyy3q6Xnrn7j7OmWR9TCk5kqaBDnbOgGqY4z2ReP1nF492UTtsdUikw1RxLUoqhaOs65q33Ys+h3ctlloWVg3gXfbGVPyZteG5AUmhUUh/uOAc/E4hoiplksnA4dUBCh0s+Cawm78spY1zKvgDt4U06HKmxGjRdEqiad83zCrG/qpsDpM5+8eufDe3mMgvapT6kFRsyT4FKqqtuAFx1TsY9Ls+geO+rCdYpUbFIryVSv8U2Qdv9pR0cBngp8gosyQ7uZY+rAQC8/OyQAn56etKSL1dvnbwUW9xnppJiy+H53UFxDIJBYdXTS3En+mqS57/wL9lvhBgEcAPSOmWv5G98WwZ/33Hzjme7jvNV5Weg/Cj6AEL1tygp/EStiouMkgw+ZgO+uZu1qhGGnUC8YnBVelk/GvC2q2MdlSbPVQ3BX0V8OjRxzdtxKsT0GlPchkuDXMHjLebyKZgPuOpQPreTBmNnwSUJ50++EmpEJAR9fIJZZ2My2tueM33C36IMpuFxRZh1n49BY3XVYRhVlbRrMClNHmKDTL6nnKJd4HV/FZ+rbje5Q6vMNGHB+CPUIHnQHoDeom/iset0f9lEmPxIucIZgesZz2ZwS6U6Iv/3/OJ7YiceHsxhoLjyEWOdGvJ0VB8aVfjbI3JYalWmEQPvpkQRuh7Ki2TKPPPbsXRzIo2+AI3bSxJVI41KrDvbKdLy9koG2yc6GngWSe7m0V9CUPgcwhKyl0d6+fvpymmJOM6RwEhKKrRnOqICQtkv0+MZXe6kl0TLro3Y00lp6NQmrKqVFv9VewDTA75mJrWYsQxLYngfKAvsRB67urhkoMqtDBGK8rCFwnXryUYuWvCzVcrDk3ALBIiIBiZfG2aJDAoIRuoRwdUvqlgiq5+ql5VgemLDXDR+PSS+FtpY7y9DFKK0gmnFR7AhKnE7mhBEyF0QAK4CaT1RyYhEquccstRqWlv4MCZAUiyLiZYNrA8Xkn0l48y5mhh8jH2XQZUkpohAId9Z87idKEIIQ0RHcx6gjFyPMOCJvex8jqOWbxQOrE1mVJ8x3Ugv4aH6eNnP4LjgQZsaCQB/3Tkzk5tEIF98TTbiYFk0QGuKy1RdxhgIC9tCtIoqtcrHiha2gIr7Z2QWDVaxzXUqM1xsNuJaPojGk+toJBPEtQLkLkOfGFJ527XCp32+wI28EWhMPgX69wUwLwftsYjPHjpw50KO6R8uZOtZPvX0MzuvxDVRDJbxp7axRq7O0QjSENxq9y0xDei8PqbJP5ic40VX+mh4VI3vissTcXLnG3YlV8klHCB+pECl0Qwqs0JjR/80szmxc9PWiiamHmy/zd71NzZetQWwOOO9BBKVnUbgRRxQVwgscvcBDGEvXi3k4FOXCEwNCN0SIifpKY6TPUxVdcvwgugyM1UQILpJR/PKYgG9T2i4I5hiBvDo3oM+Y+/da6xLbzvM8oJlvhTzWJ3M6Ipql4LOseJcJd7YeK8f1iqiS1MUAnte5OrFiBayIJs5EGyGhzFmirpEU/4B4HTGbZ8GfCh58MCzpahTsBfjcEVaywgc4XQQdXbHZRKV7auLzl5A9Ph2WYWpQiWwnS8Sn+pYTSiX1tsJRay85ktjXSFTlnSglp9m4fRApabu9W9EPVKZOslORfyFbyjFwhVfaeRfjBHY7yyCq1oP4luZhGqjdri4CFq54BVckAjh9rCSibmSKv/yItyamWkxxv+P98V6opDHqVxp9V1MuedxoZmHZY9E4+RGAbCKkqtbpbw+5eELglt25sj5YcG35a1Z/uu7rjylMueuh9fwv82bs15yWzvHRPzh27eMLFujveiFRn3AFtiaRCH0bFt7EFVPVS2cE4d1GYB0ZeEyBmvhe3DE5LYrpJASfLWEpaoBldIi5xdPwall12S5meo5uRuigNkyYuSbDB8tA13/ez53ODc9FPFP6aUYcsFwFAEoNtbwZ03rxyo2jGYW8pZVxt1X5tkTSFdkYhBN2KU7WIjFIcrQIyvYb0T5SKCoTDZoNrR6iErYnybcqWKmtNhzsGKw13Ytb6j/aTctJSau4k9HPUk5/flOOdMIymq+VxZZRd+LFeP6i+t5EYYKkfaDf+7Ouk6O9QdXjVZ658ThZ4W1bsjZfT3o1k0mA8MVyJr2c17SvHAL8nz3yYnLUgwhzfsGObaA+hBGH00a75tnFmBJ9Mpa3caveb7WFAKJDgXypO8If3UzHwDO7uJsiNHj6LEB4BSQ1HxDeJQqewK54jAQ7c7Wq3v43H+u7PiDAGFzLsL+sHym1805q7KvBHpqUSaq0FuSY9NQRLHjPDj9ZZAjUu4/uHeGy2hk+vy25Y3yP9sSb74Og2+1IcHz2O3k2D77JSGJ0mEzWTAfwIF7c5K0w90B//gMpbuyIze/bsakTmB9UY0ML/AyAZKVBTY0cnrkOi5AIcdfUyoHzHplu4Z3heemjY4l83pjO4KN7OTdy6En283wbmNZ6mMwCGhg4xpsNWCkxtPlaSvvEuSIzgTK4Ki3Crne+9RZEwtTTzVrEKhiZstdI47+qi4+ZwqPb4xIcRaL21Z1WCG8OMyByjjt0bKB2TMQsp4miqa3OaScVU83WPAVdGle61/EVR9wdhQbE+BoYHPI17HuJCbSlKObaxLTxiaoFEKgB9LIWRt/HObfBOXJpny5cKFvJbh07jRf8unjm9h/sikJ4skgUgLu4zqwj1SN6q8uY4KJEIn6FzEQgC8CCpEbuSRwetUfG0fGjk6kuPe0C8qTpK/Q7RidvwOcQyx1tWrVijrkxMO8PfsUtEluD7V7TS514LPp7sbfZYgrr67V89RsvecuPwJmEQgKKkdEAuRDYjmC5Xkfbr73LS509SaF5gOycmcMooXMrvBBttyMYwEUhOP5LYwk4YvtAWxEjt5Eeb1KSbSxf6YtA1msXoJThEW0j5nN34pO/yxHhHz+PJp5lvOqjnsPhDAX8pYY9YD3acNIQCLuM9LU0EbBPwXw4R9G0qxNEv16CrTGLy/jzv5WJUxSVFhIHLhMqop1l3iflup9/E1yt3AErXEMcEp+5h/gGwkvU6ihpxBsdwqcizMJu+upLhCDe/jTDJliCJkGMN2VlvobUuX4E3WlK2Cfp77A4mBMafJNs8NtfhsXrAj1LFzvGfRY0kfIxEEsMSF+404SsbqIYMAlF2AL2Zcni37toddCY/0RqwxK8sSEgpPdNczVHR/mars+kzHrYu3jLkiKV+Ou2IJsMuFVVeibIb4tQf+wbM0MDR1WbMsX9krC3UU8OthlPBQwdFU3mqOUAyzgcHTkBt/gcO3dO8vRI0s9gOogV9zK3ftRi2tMPgZ42OKQfhZ7sCX7k6nuoiSSEQEkYYJeg/Utx40nJ2zSR2Wdz2zG0HCStngIfkaI+ZAO/t4ZJWR/H2PydjYIV7vX9VgUhPFzmseBxWcrazSgiBP8vzVrVsDw7eg0sNIPd4Yi+OfP926q937L0WDQ+XAuigqknjpM/WOfQwjqA2Z5wW3TeYCBTIu+U9aMGL7V2TjCJwgeWBiBxa3e2826IwxlCEUOIMkyUbO7Tj/P8TfjlVW1q2RjRcWy9lXBU5SrrK+mPljUqN9f1MRzKB6QkeQ/vXBAiuXilzFoiuLLrWitoXKcjtsmwESfX7cteAOrNODnMybKZVXR0mH+y/nPvYbom8lVUIHZWTFAAGYcGV0adEyUzleLophtmO94XUmFtBpe1sRj5cnAh0PZwJP+AFEuOe7J3Edi1SWiqpHw5L7hCwn6ceSAIK9N+qgLu3NupzSGxfA7yHeYJ9Go0+B/2pMPoszg72Dd3KvUBPTgb2/a2QvIgwyiNo0uOEUN7ODjNZPR+XUrPKezWeqHcYDPrv+wxpajx8+l1VKUyRMLCY3qVW7/KyvDTDQjcSgsIv7RTm/xtqNsf+EtRWdzxqjeJfHCB2PZ7ozWapzVyxm3zEmTYPhRNkAXn+uev/EViGEt0vTdkaxi83uPgBSeZCHykh4UCz7uvUXdUpolERQ4cU5lycKDP2w0pSZhKW+4BfG7Wdu/3yZ6Ekd48uf+7z0boDNaxVlFGjIlO8p8F8S6rxI8+lVgfeMpVMcwYogatAugh7PFlT1zqhtY1uizC4toSo0/rOemsyoOTJSAHXJqX2aOYpPR6QVp7UAzQZex9w6LXuhRjFWxVr2Je1QVi1fn/TeRK7hplpo15xhqp2ErpCaG/4jCHDqNWunqP7K8xRyuYzBRz/NSZoShw5j9S+1EB6EWBIE8DToK+q0AnvMcdbgOG8PZEYce9eGac2YU8EyrWFiO1tng+gYL4qheco73TCRBLYzc/r+0HxswGoezn8sh6soKZYzf02WLYyWhAoADkF/rPNh0WRZPhrL2zTKMm2oxLH3vPNEVAne8vIYdPhu9FLyV/cCyJjLeIso0nRWxnnTLL0fDTQV5A2OIVAeYKjQf397LX/HtW9nxsNusphJbY+cQ8xVnkjLKYdDS3bLg8vTMrDqSIfqJxI+6JRJ392ISzKHNioDzXAeCDXU4S5c4daYkxkY6F4TsKn2E25O5VAjqSgem2SoTGbud9le2/tFcEBoCmytc+gCR1/ZOuxzOz4mZQGR89XJOha9Yy+4vWzdOiE7gdMkBgDLOkVGWMwPLBmgo6bGiFGEj4SXhKVyCPx8wsFSUVoHQR6lUrhNQhs8E8X2oIMFVD50UQ/4ms865zfhz13AdAWdmdhw8zThitFTjpYAlFhEfcDGcw0UBjqOXx++zkLmtPSJerJz6LFrrCdj0rUYyQfFKDdOrZ4GT2Rx8mRPhUnil19orU4VMT6IRUSdPHKRerC/wxVCM5Rt5GgSOmLSFjG5lvEwaIq9UVKJntlsN545+Ux7FWr0hM5q/arssD6sZc6se3sgJZxtPRg1ZrxtE3sDJxKdIFeruVZuhllSyeK2ANXVnypc+lDIHe4ovFY7T7txb61fs/ZTVqB+tUzXq+ScRXX/R0zE25gPA7nr26rTXTU29TMDsASHvH6pg//RHFNP1e4L9isKagK1vf106ITCLO60GJ571G0q74YfT437e2Z1JqNQlEissXTHXdSt/YXTA4EjpSKSUavY6PU6IhZDumFcEan1RW31ZH6zVtM7NuGl6vqjJ7SUXwHpZWTeKXYd4Ak6unE1L4drFO9zI5nlfDATdX9Ti9gwzGVJ00tn5M779USUKTG8bpT7lf+rm9994/ae7pWssTNil7asjQff22tadqvXpiOZLiS56Glrq463W+pT4c6916tGa0Ocd/ihjlnjOInW6JE1uX4dGXcYtnCED4Nr5so23qFTfaE8nr+EvjJMICf0DScOrhkQZLOexj5dcK3v01+c0w4raD7iBfQ7hKcmPQxHR16sTcJr3IWX0ZSWQOniIQ/opKzcsdh5ajrDdO3Epe1hb2qecyRbgBEsexMWg2XePhgWGvPBgjLKlFSph0gjHRKf6m/GcxTrFt4veORyz7LENIwgiZwQQ3c7rWI+2zhHH6n/sT1pJvMvRekMvAKMmMD+T0KzTu0kXHw/4DkMSjPN0HDhnOpGQ9dGFFMhmJbq112yBVEd7Y00rWk+dThw9HRfrmWHV/9UxTPc3N2gpN4ylxxBkG3VBJ1uKPUiuKZ+PNN/qMjyEq/C8jnmAEEY0Xn774nbZ0TsZH1v6m2NnbAoCZmrv9RdGzPWmfguIwF1+3ZljvWyi65U13nMnwHzGdo7D+uAYTrPsvpxn+zMK/pQCWVqjJbxHTMMZdjTPzh5Ngs1+tpRcGY95i8bnWxOgakVTDAM4jlAI3OyZQXPMmqcZQZYZt8f3Az4mrrU1S0Ns5PVhsFVQaxxTece+5pNkC6tYJYbHVMkYc4kQf7R0k2isa+O2F+0y/pwsjjz1p7UJx4549L1UxovVSpg9v1HlD+ZTabR1/r2uPooKS4CXpXM2eVNKSH9UriufIuVuqHRcPvDzMiA/fcwZ/APK2upMs7ZZzGSg2A2eBvnvSacslja8VHPkhPkEmxQIcKPJze78FLMwtAql3PHitf243IQrwNq7tdDtu1N6JEO2mgMNftYaWEqg87LWhSWidFMj8Id73Z1d7U9MOM97P0j4EfHQO4yYIQjs2FF+Nhb5N0/VUYe5JUTXvRWe2piNV4OnWqXqZR4YmCY9Jliku2Pn4E/oUnF6ZuIM74rshUJIqJC8VquJLuDdBR1c/AVtFOdfEaMBJjSZCiLYOg/oVbEHHN7ydQBAvooEMD2QN8zwV35wNqlA8mO0w5vZ6KgtDwK33/WUTYUfSpU1fFNGiwIbfJxKeXexTXyD/V/G5gmJKyioJzgibHVQ+HdxFYA7MPfsak6Ja4VtIgtIUFEuEOw4Svt7cz9x1Hx38hZ3msRdDBvJeYlu9qkRLR0IulDTS5s6o33oRAKDj/B+UqPLNxC9Xh9IOPlnpJzXJRizDkrOQwz+9n3hifPbHIbfZrzKEZbOaEJBtzGKehQ39d2b4gZXzSBihrs4e5VMpfMLin+0iMjm7DoO8olDPV4hJcczFd2jNPrECcOIDVOQf000OvGm35f+RKI2ROKS9m6vYZOz30IEov7SDf5Sa/lcYfrHy63ygnaHyHKj2wp6ia9hRrWCsLnWsxrLiNhJg+Mhr5h7CLx6GuJZC6Qyhaf+W9vyiFTa3FXo15yr9x4/K8jckqQ/I647rR/obqiU9oEgVZBCsCHGkdFyJTojNtTzNgxISKsc1Ub0LKWdz3xew2sZMZEBb78fdBN+sK4mRM05knq8nCRq7gfNqdtvMFsYD1oFJn+d36yHPRDTWyU4s/M5gpmP29itYbVkkU0Qyt2+Q/JppFs9PbuxJPUjxNubkZ2xhET9lfG5up+ijETe6eJMUkoLHRBcmsdm+4j+QclUWyqFAJwMZUYcBvKdCb/hF0Elh1LsndTpVkweaWooe5k0HTjmRVQYWULZdTeIAmlk+3ZBSLUwrzJHxKK7gtdeMtrquRc905bfaQIq03B1cQvdliESE59m6+h9rjVTVgWgjXNejD1M6uFSDUUivrQpjbHUVWBHdvV1c86v5Yvc+q9Cneq7SUcPa/91bSiQSwE5NCE4QIVn2vhvbSzP9D2vw/pY0WhUb76ks6ZhV9uDiyRR5VzF1P0o2WQ7pV2dqlKLLqY6813HyOsEtmPDtZAdH851SF8Az6WnGREGm5RAyMy3jZFHIqxGhz57hDvnBlUcxFzBPGDWqq2TFz3RR0PHs4ba4qrEJvHEJKr7Bv9CKlWkOwVGblSZvGWwBWj06G8hVUqYFVu2w77zfob7i8jGdauYX8ObSyhji4rGhNhLV64Oql8/8ryGehZmsam08oqY1SwQtXZlHUuh54VAmxdZNuaBR9Ec3/Pb8YkWlE2Z4RpPgj2qi9ys9wmPeRmJjk2euIkeKmLAAGYrJXg3FS/rCyB/VXBBcHZVQjrIlOMA1xSrO6I0RAuGubRDnDTcqeGNOhf8VKlzTLHrDb4SbOMC7l3L4ZS03y6gvAoOLfp4v4t2xNWB7a+k0hJR+X4n3OMxqtOlZKUfQuO3BfUD2AnTtkiXnYPtRunsNTUcLbYwGUofs3kQinWkep4DRTkyCgYiCAIDx4U2Wi2YUr9aFtnWYdSXqzDwZyFB5nwJgNmY44Rv4gE8qoMsnV9OJIMO0lxSDjQxzsmEiGetEAOTrKtIQ6y4IEXhCnVcXfaktywS56Mttc2zCVQf8OWTtPYda0QNyCc2IMDgbrtS3XpXWQp+eDNCH+FwwezhJ/Z7RxGGEPFvNZLvN3Dpd61wu69pINHdRLSMfPvFmHMmOSe0Z0tZvCGCiyX4oBNf5JdxbcEDdchp4mLcAiIr6jMbIsYN8nqi8hdE8i2cZeY3F33mL7Q2JQng/rQp3g/Px1+6i228IECg8qzz+TbRU/nzRXLVRb4hXw/wyctBMVDHXXjvM2dyQeznJjVhLSo0BcPEmrtmalMZ1y3Bf6kXSHhumgodf++K2FkoJGolcegUZS/3GrgVrcowz4SpRqc4MxvjROztkPHE+0LPTTlqHLZwNXxbzFRE9pm6ukVtFZ3Nxk/j3BI8IGJg+H0cX0BnQ8IT6XDY9TIeoMVHUYg5wPUi9YMfUYumH1MdlGIG/IGNMIbHu+ld3Ak04iC06DBwM2uIrlAYOBbuMQ0M1kn7vQhlq+lcf+UT6rMkq9ib539XGupk4iHqDmJfUF0Y/oUshlQiO431Ci2JHi0ijOuoS+zb2cn1lBu4nt0Oy4IE0059+hfya0uTWIoR9MNrOfRq5r4cDRW9+yteosehCOpmiw1mkNOiSxsHJH3YCS8dhWe/UE1oRGHAEB9TgNWpMcHor+otgCuJJR+bU796Kr9e3GX10enkDY4xlIi/KOqu/634uOGafgcnwP4jMwSQi7rcMlB1NxEwU3xHvb75Uz+3mA0S3X2y0mi+qJb5quii95uhD0Q7bjrfKb/yQmtmJBqv6UVB2N94WscRgIv8GhZhF8SF67Xp6klVIlg1mEoczlNxblCyhVh+js9wBEaoA1G9GoEEboD1tdhynntPgTQaYOmA/pTT0YNhamAKU2PODaxRQGCakMhH1Gxo8q5laOItwi3bf7/hYGqXg7/yK27X+0j9zJC1SisC/b468Q1pAf4lCASLLamhfZaP4zph2KaPT8V8swpw9gEGFtedcjeubUZyuBup52bxNybZZjowroR17zMdC1bHlz0O9gFer+Ks4/crTd6hXL13CvHEJsWiUlmSHYFbI4eED7sUQih3VT6mlB8vLUD/AQIBwaET2uJaun/q1/o8rbPrV5fob4zWH3ennYRo7wSLM7ns5fx5jm4ebSqALKZymrA2xegkej2ptmo1ZB6Em1/dMnTSAyA57ea4JWcOx7a5AYh4dGjUHJh5JoCgI+83x46AMFpEd4QkJ6j+Ug2D1rcTSIMkF/QRtHwbree0QGrD/T8ZpDzgfv9mY5ZcWsJMVpigR3mUQORJozMH9gf43i++HVBOuYyJHW1eHAEYpsD5eWvHHmRYAmczZKCP1okkUidDxJT5Pyzc4YVQFjmxGaMQa20tIC84LitZFHSupQwF3u/igWnH7tD9GnsPciSa7HMx4Sc/gm0q90hhQYr83f92KLm1jCTPEUO460dRe12vWCueuh2eTuTsEzERgDbTPbRc20Fl0/mWUMNuCWtYpL83Mv98/OwKi5Y8ClkA1a6ehpiWC3up7UQ+nd8zIqtrHuzlGRYDvGCD7DVb9o/zgHM1nv2bsoBdmDR9HRHGN74tBC9ah75a0LVPTAXGZYR6Cab6eZsa7zMb6QkfhxOm1NOu3NEh3ojc3fG6ZC8LVOUP1gQdcAjufHI9pdZPS2ZZrrfuVrW/YjTaXQJn0bW4jFb58dwasQMXv/C6fFoY9P13Hwq7DIrbaBsxnBTECaE6eEEr7nlJ5QQQhg93zfdDg44kLkZ1Qi42cPbIina2EvoivcDLyYgahXnKFP5hWFia95BfHXM6EzhgCrG9X+Am2nq1sS0V2zwCOPKkGujsmzinD0EcQo2Fz/SM9PjM6e/E+WDAlGgdKE/yFj0rC2Sr4AQIJ5zZQ5KoKNxyKNt/Yb6teaV+3s1TMjhVPFM0qwKCGUcApiawdewa8z0BqR6gwypPupsdId5bgmS1A/LpXDCXpjRFvHg7JtpE/1xI+YFf4TWWwUA9NtKgjaM3ZddDUNL0zrXYOYhxKW1uMvvoLafYVpIluFmnTcZZWWfC/SnM33SCMBoGt/CrPaa2xqEsjh4gNAIQ9GhZvavqfJQVmoOpzH9oQXtvkLt6NZ3l15wTuC7wpWv+vIulokvj87tTe7SYnwf/N0uDmCug9y19UCXlzUsjxAp9mG33jd8G9q1lzmmN+7vME1Rc+4JAW2smB3/OEOjXkin4ecjzkJAk6ulOfHdFg+3jXwU0F85sPwjblRMXb60tHMExP2sjaas8psLP92cwCZTMv2eAXlXPa8KPaiNxc2PkWArk3c+5clh15W2whwPyx+AUS9hlgP7qxbnk3TiPULo1tchBVojamTZ02ttvyUBkMorRiR9KsqBjXGskFYZ07FlJ9q7lR5rTfZqpzfktawW+1f2miafX80LubbvzRTtV8atAQovI5ADAvfwmynNB4zuUJr18DKKYCL/xcT4igvuDYnEnEXYd8J70xozQ2/r/xNGmPhZgS4P8Rlh7u6b2icEzsFsfSh6Wsi9sYh3EhUTrGi1/1QE2/D2NOt1JWjceGfMtxPZy9AZ0xY7qc24UHV9hkAHuYAu+fqMGC5g8Mjk8z6O+QYNfb2tQRH8zY3UMik1ZT2lrR2xoWZe8rxLOdQvXFYHWLFH7VyovBdTiImlVNLSGLqsM0eKhF3e37+xepTwgMQZXENHou0BY6suxMGijdw6BlVrclvLskm0BccIM2/MCtI7IUTqnKftqcNBXcLmWmRUFN57moQV/wxvpNTZJ/5ZdQG5ylEPCQC1134PuuNNwQ5O2E/EIr7pmnV4Zly/eDz737hkvuEqdX23qg+mXzj197dXbxofeS3qHNHSg+eSlU8HGfe4PtjI6WDAkGYdQI84xQPaKCRLw/uGnLc0KwqjuTvoiVZCf91ZcnlerF+LqDCHkmXs4InC79shgtcDfY4Afx3H+a7gM5pZvIm+UIpCOMc4Cee2cmxzpCLHmbRDqj2LSMd75H5icGRlWpj6MOH5Mm3sGNDjAPO8RXf4h2dkMuql2XqqVWPMTDMmR265turwV9uYkU7m3N66PX4DldMIBusbzfktvOjnqUSP9+cUhqvTtO4qABRpR8cuKZfMNVn2D+9kL0vevqbxCE14utjthLv3T+YZHtwfILNYUK7btvuR6lTLyF+n/hJcJbnb6dMgII7qp1qeWKdcwv2IEGHrC9Sj702cD1lEvK2e7hBo05caY0DTziAY5PBJui8z0QAJ8OXFMKhgIywHrPVLch+N9ae6oZT8xSkKpQcz4OUdxjMrIQmxnFZxloNqssQT5vEDhUMf8mJfe87sj+K/07ChXtK3gCnhBuaijgObRhpof3D3smeTmXVjltlbNeBj0aGctFH9UJ0E8F50HsLodyymYKUc1OhH3MFcNjRjZYfsOCFZbb4105YmgkIT9mO+tnnNBf4J8tyHCmJJc7zqi4VVlvw9aovN97GguSr0C8tivbgPSfWjgf5pE9Arf3kDoJCt+RBrxje98kvmT1Hldcw10+ddqI54QV8TFxZbwRSW2BTcbYtKA/66fpxJ2cJz0XQw+QeFVzfRW1Aut5xqADGqgy0Fnffb9KsrYi82IdX46oTI0cUGOocTFZZztNdmCpz2qk6BUUJjpoOTPwxd3ltloTuUJklhVzrJslfVotdPPZ5AGBp6DlulMPCS+RcavSDKWSiZChkKDKN2EI2ApWhSHZFRExkEFyMPyhrWV6teq9FEWMjK3XTeEhXilyZ7pq1V3kFkFRyI3AaYT7tByWpsSkZuc3XIs1U3I7LtOlinYXjlgHW6FiY4mdfBfCEfhMzObekSob6AKNMRTXtbZNBVb+3vh/Uz03tPpUhBirjpUq4iJ/ecNdGgGsO6jQqtBWl0UxGLMN2t6tZoZcyCYU6DmSH/PlkeyTbFxbZsYknSxYrOpDu1kheOW8t49XdcP3CnGnFiopT866vAU82txE3scwENhCjExyXLLW1KZ0VLWZ9DuL+G9l00BvzL9tPP4gnvrigFpcsGD0/xykfBK+Qs+tNuownw4AAO7IIewoBUxz/KKmS/WFxG45bd3g12nDlev8xGFIQy+Xi4QQjr+UM84MkFDKkzWRg6i6TaqfNOpiJ0Z+FRu57M5ta9ypDpM7cWTVp8y5Dx53Ih7toWF2CmuJrDJs7x+dlP3Gl9909ESDk6RghlVRGUxizDIr4zaub9q5Pt6nWKyUuft1mdBY6q3VVhPOz9wFKWfzN+2wJwPuJStmivA2636XWMwTYxDBHajkUEUcQk47xse2u8YZooh64y/b7wOdevDUjmY0qv1eWI9XgaQOts7ddJknUxorjtgjAT4s0U9JbttSFILQe/1Yt3qVvYAVnpLAanCCVVbK88Un2+ftMXTe/U2QOjrDsKX4rOYzDOOArSoxKVbDVlh8x0wawgIWGTlSPClLF7nh3n/9FuLzFuLVk/3tPljPvl+qxjL8JtPJPRh+jC+gKp5GRueN32aFIWEpmkk1nYvim0mT3CQ1D5mPz05FnyD5kpsoGXv9+ANEl6YXaRPgbam8L8zUorHIZyPgoiTPVaBjjGlPKfEv+VCfExIWlfwicRgfp3ulqD0fQMNGj/k2DlreAVgzEE9xNcc1WsT+ww617+Oky401C0+MPwwMgnrUmcbqrpebF7U4ROc2ZAmnFjUb63B/RtnCf9TU8Ypj5X9u9lj7/ZW6J9/ybU2Hfy+1wt29rN0FckEIDJ++2ioGaxyFsHDY7Ve5Dj9D18yfj8/SWa/8sx0mRL2yZDvxT26zZ4pm/MAsrbKvKCj0XbDED4b6g2w7ug9vAonv79exHuAYDyD1Nfs+Ciyi5c0EX3rq+xMUrJFznasCizTBp08SK/0klwnZT6lh8JVffajQt4t1ISsJKhncZ9kW74KluITDEsWltTtceMUqWsq5C8jaDEANfTdYpqZVJvVMt0M6es74CvD0XPJCA5Ho6ZUdxRUTavG3OsIgpSbtFY7ceTKU5ej6X2CX2FSW3TBcaQNEl0XgCDU1KoXWQ8J2y7JplKkg+Z8aMLuozt+chd0D2FMcb0ukEcsOr8GG4qhbXWMBCADOWMHzs4qiG8TXNvcqInkhqvosJcfoloaeI7OGTb98h7yQAaB6UpPOxajIM4KdkMeAwKwsL3q4Mz03pXi5s4bHOF8iQUxpga+PV37XtGNcker7DT1fU89FGyYksuxiaLoieHSKMaD8WTAnRaqZ5CCun3ItvxPce+dLLYJxFJtXuhaNmcgnpF5VlUEHdQtSEPbpYIoq0C0DNQvhTGEzhWH2pD5UiYGcFJqLadk+aHnNxs9peigXY0HEFQOZ83ngx9cisuLpPXr5SawG9LMN/PkHVQt50tr/ib7iYwTArcpAWXONavKfnyH6Ah5OiQkCJyRrhR/YqSaokp5HNuYoqAyq6h+PxxsblleLyeVStMVHBqoSOnARKH6shR0DAnb/MjlE5KN/KlB4ytwnkS2El8LQPHJg+az0pMRzfV6YwgPwRz9FG1SEdSdu0A2qIGTRodyrbVO04PO3F/f0nNlZWt00T3JBmT6akET1lYYWnRvediqtYwEaZj74YzHIKc3TbPmDMD/utiGPnRLK8UZ6YCVi0/mzwEyBhMB0NoucR01acg8CKkJF5QVLZgTJur/8BhHa0VrFDssgt53sAIuW8DraGErJG17piDW6c0pEPXweYX5VqU2cllA+QtcTSR6EZ+zORWaTN2hMxzJ9LGXgozJRWe6LFk4kzP5CzfnFA6BxfDegv534hSGt8mVCFyCy39nJCxFjkfO/dwpl/TzJzAvHaTqIQ1B5QZDAMWOj11mECdKQjp+MtKRSJujkfFxt1ujQwsU6AY8xbf8WrmpRSBNTYmQdDA4d+m6FD6/70Pq+wycZ5x9JoLpM3hdor0lkT3BbadNUnUF0kp5HE0Xx/huCYzJpkSKkqmElzYufrRTKCK3YHCjfaeoxRNOrxmQwIohKS2fsvW21X8g9yj5DqeDxk28hpT8345KuMpsSkuyiMiJxRirJ1Mc5RdRzAKWsfLK93chtrzB98pvkOeKinrSo3pVnShD0hU5f+PMp5vu4S0E9gUDl10lHHMYdB8cJyoA/jMAp0ohjmfUowZD60Dfz/R89Z39ZLWD+/asKtTpg9caTrSn7lmIr00LgeL5Ix2ie0kswYhJWxgkLHnAOb0HsZALDCPHbuHg5WQrEln/DS2Ng3zJ4zEYuS2IJZ0P06R9VijyT9Bh1o+1oGwCHrCD39j4yBYfXmxOVNNmKyZfjy7rbNrJwLSmmxwWD7ou6xZd5zCTeIr9iq1QPfT4w9no1bNmPn3GMSDEBOZEKZrZ+sXhuY9dV0jtQ1eUpxhcJtfzAsoBHugqhO6LnXchdoEymwcHUBxIWKsvPN05veWl3vteRS9Ww2Zy4c3y8YQudT8bGR8U+lrO1vErzKnaDT/jMmdnF+4kZke8zK/0zZ+8wRJhM5xcKntuQZIn1s7D8u7f9rfQsMF5+fRsdlbdzYsc/ibcxlPdoSYdXkrO/RZN+QEMIBVsMmdAml4iuzxCwd/azBus3b20UpR/uRS0QnZ/457cleExkaVkX9i1J9ixXUkhAVDbn6Oa8LGJAoC32ktu9VFtHYlEz/LmNhUM3UmnMW6RKW4dRaLy35xIIOcoRf5gPb7vjbzQG2jUCARTrzteZPjscnjydbHMgV2bisak43WpPnNHmbO8TEbNgARLWe5kHndlKBfL3X5DM/VVyvZBr1HqdhUr5B9vL0wrDwyXLEYL3GKWwCLXRCkCFfan5IuMx5569C1kMQ2oFjhiuA9QkbvuPy9ydcG5zZ6QUdVg1GybhQZ4y7AhiDfKdcgmiMuaZGMPPFJp50KrgjqHAXKHiyAX3eECKM8NCHCKr+7KkYb0wLX3Ts76Cb8mi07aw6G4gowPGHiEBWiohYqkUgEc8vCxT1a2aZdw6qr+Lk4vrz8OW8MNp2ngmiAejVGROAH7X7qiwPYIVl6qrgsJt2t41RgKp6WF1XZzx6eq7aQ45sqlC6yMhTekPDHLKWuqLbS730fBCXgTdl6lOrE17m8THsjWqKsn74tKj75ZVHwV1H55BVh+mX6nE83WwuT89Kwczk2aSWpsC4wg49XVUZGOACDJ7QTzZWiBXH0eFvviR+QLLDvISccKKz1p4tkgjbvbsbUw72Uxbg4oipuqaPvWGnhCX0kmeGFmv3rqkPizmNz6Y5V+ZlnZydPPYkObQPfFDVYvYC6ITa5/EY+Ao0lpEtI46dI4egQEcbMkpgGZxTKIDKgjuwij/tO6sFnvmQAaFfn4hdevSqjp93yswwUWhzFqIKhgN3ZKYPVkduYZBtrgNBZov2oWbyPQwhucqdOL0O8nVFSwgp+aaRv9P/Wuqz1AKGCOGI811hbXqinbt3TyyWvBT3LcfeKo2swN8zQUbPQSkOTbBCoqqY6heuDVOmCZAH0LSURyuRR50L6fe5B180u/fFoL78H2sXRNyPZ4rq5/DI+PkMGJ4Hd3kKteJG7y61IffnfsxRVEJ+nsFBctnPsjrGZFgHdy3SDq1g1ncNYt3ppZ/2l6ywXISOH3ERk1NKrvSwaVWOzNMABPxIVKGnryQHcP2AtJ6BHonqX0zz+0NlOu3+yARj7kC1TF7xNJG0ys4+U11C+FpyrdV86prxnQ0Bs1SMNsyg2hcp5XfIzG3QFlfjXGC66P52vNh2oZDXP5NhTL6AmHR22Ggan3KaYyE14/sOSN/QWcn4n7I+YIyNBSV+hLxtU7AflKMXFkq+qnA5TnPy2TMuyfbky2pGld3cS2N43JQVQHLR23pMdSfj85424WKriNYmKSx9cx0KWoZFsLfyzZK0ffSHx03eRE8yEseQFLdFYlEvfuuturZYGbvbXDUgjFaWBnZHB74uJDDrHUi4FEFA3yc7TANyVnod/wjk5gHqa1sM+B5s6tIznlS9qouX2iq1FMjJVvZucRgf5ogfNRZYDD0Kb36bswukO6+W5+ar/tQTJ00w3CuMCNl1Rt6oDjvCZz2QjDw5Qo0vA6uQJTtNuJ6HUFnnn7/EVj6ngkyIBODoHDmunZyCwPB4PkZATP1jYuQjtArrUqg8vln9XvM9U3thHo6PM6RZOHUR0nbHcPAKIip+2cz+EN9BWO0jlbn+clnBAt9YExwqsx6f3yjiVj1SeHLMWmCJ9zU/aD9W9jVQLFwsfHIzaCK4W/EJwzFYwDEcpxuF0iHJlQCnmx+LwocPkZ7mxz+zV2JRyBu8T77iMg4bCQl9OE6i89JKQ2S25lb5SrOqbnASMhChzasRbFCurpTmyRYCuMZSHfRrzGwPdNzXL0/tNU6dOMtjBmsGrHCl4/Lp7EkWOsx52CHdEh0FYxssC93PtbYETYGq3yiYwHON/C0KiNCGGZjlCUoIWIDKo0KVQVdHYNgn0/KbgIrh1iDFEApBgY83SEVCdkF+rOpf0HNFNkqkCKoA+oZeIlZyI/wD6vWHmyTmn9gvY+EuQ3DRBz1O/ifF5T8JJbVQ5nnQ4CE03ZyBtB4LqNIG9COx+zcw2mHm95OS8DiIPX486tRu/hnJDuTzlZDe2r7WgLMm1PLqQo9RkmBtQbif5BZocbHKuUVTr+FSI6iNwAM5s67FlsOCufwpn1lQkVua8cFOhnqOfKja8MwQGy4NL0F1CSY/2MAO2MCJaxbzLshyNkWcvvbXVIZz8+Znw1t+JsD8aiEZ+f1/uczMzktTj5967pgds7zUI1I6/it0UTsOIg6sF3yH5CPJ4ggDiC34t2qAFYAgQTLA38GRzP8EtHG1I/i9w51W9Mu66SLlux3Ky3KX0RsAnMVGHLHix6FbyQj0CUgXqjobuEQHzS2ebsy9SVRJ+ARqAARVs7bfWb7/BuwpKIbo0CetIrba9aWXzuHixdRAIs3LWIWwIKYIg+q/N0wQ1zAiLQf2ROUXBsAXMydristSvXGiH1ueS80ttqdpiLc+0hSt/FMjSim+Z3uEdoZ/eHmzeLlsVM/S6jFw11NOJZmg4/HzOrTOV196PL+XtacB6HXoW4OSAio7DFr35nJskX0kAPvXmbu4SIW4LplGcduxaNRF1Lzdycq5Qi4zkdcLjtR8UMvC+MqDf4f9hYAaMvydLjG+pSj6TH5HiHx6iNCXuIbZ5kNdCI3z9mda3k6bHEo4jbmGNZdt3uS2r/cEG75iEDt9wcq8qGvd1cwgihmfOClGPInE5gmKudjkcWXydXqwDNwr51U1JF2WMSTLDHzegD0nowNTtWWiMfbhmQT1b/iLUg/dg8e0IftLtAz90Do3EPYXbBlPYxifcHN7w8huD0hvxxkc6ixNmJj88FZLuv4HSK0zkU9h49on7vjKnvbLvMikO6RMq22dn7ZvsvIjk8Z3eM59MACxYt99EdB/JyyWhmTU2+qECwI/aiOIsJjlGi5GB2uO43t09hczKIejhXTn+vRbqQr96lKyfuoPPfoToU0JflzOlfsuInUgKwpsqu8Um3QuIeeWw99J4817wTLG2W21rhx1iREDSwUgUU2SYFK/J3NOhztHW4lAoDHBz2JShh1nuB5kCxEQZKaHIK6zTtaDYeDQrEW3aY4R0dGfsFZiTf9T9OzkZGY/H+65zzKW7g4ZteIVAFOT8nvrY3n5RSDpYk6hoqIQbhdHpMSsMpqoxU1XyI7w9X3JfdMKpvGRSRf6zanCn/CT5tqg/1UP4gME3R+0mUP/glgjupvg7gFdGmKUuFJ+t4VLWgpEYVg5IEQ3k5XCFToITQbbPiUF/zvl6k+Pno/W2Kj+T6s2FD8ncB4LyW+2Fxhn2zfiLHV1S6lZdXZKKOijgpwMAhyCDOUMc4aYFnh8sca7Jn5JVD0MseKyQpBpMhyVJsIfkIcTUpBwmkjLLnmsfU+s/1tQ1fmX4yTxzrxfXPVY6rIzY3Yda01FW0j6NF2fgyXYCoVQLePvT1BOU+bVjARWf6VDa7FiUVdk6d7Ej2uu222SUsuw4N1Jw8qOUyeJiPfRlwChDx2P8ebzhmRFZDBpkuwjTG0svyzJv1qlkJYlhj3vpA2oPZ1mMeWGyPnFu6uhdE0KB3jtA5xrc9Cksy3yBfTQnMSKVi1hFT3Z7cWaXkU576zTM5BWVcIhbqjPU1NxGG+K5W6oDkER0tl1N2DYuRljR05sTUaWcdjJMGchVpECyPNyUTut2zpkeDy94CNTqas0NQy2h0o75OpsrZjFMpgRW3gOo+/Puh53bZrmkV9VBjZ+CMeYW+Jw4gWAbXiOa8ERDpRFvV14LSRBQx5l+DUrAMa9CQJWwgX/QlcGggviPCF1BkMDHmele56IVZVZc7XqDQL6hSBTLNVLneZlcriaoiCX5AN0aKmWnHxmrmn8yMOrhxUIH/2ffW51s9snN2htpOQecpMJp/ahI1SGtiLPFX2xiqPbYXStsidzFeU+Q6fh+Hij5bIKDlXnIJkIPMmiAed/swqvB/W0CIls7MWaxh3+NupqDMIZvWphmK8pynpyJ4pxU/1ELm8kKQQF1qzUbv1eu+oviEuV0P3DwD+6aRkLDm9rjHAjh5VnwU3KtNcx1URwPuoflCc9FkUiaptqWS+u0k+d3z0GeqjNaFBv0+1Eqh12Sidc8J8V5zNje8GN1KeAFZnnvgWtTTJwfUZT1cOUk6xa0G01diPEDE+dAgsCqAY9TT0SgsE7ZM6e+9gRbtCRcj3EnV88MUTAJttBaiBNf+S1TiCpK12y0cEbmPyl6sHHy8RJP9WRPisf/i9jqtWwOGxgphaT7U+LRbidzd/j8dIr152Amdcb+/9TDyCF/0a1NgM9TomPUjnHJNxe+CaMflnM62zdE/XxohftQjycOVpoGwtMc65eBXSUdESvkehiPYl8W87XDYUz+xJ/cKubTAkevh86ZDcm8rUnCQMT9Px/FvXDOKQHQsF3ZTZgAFTKsUbrkkl5p0eqQIthIaTw78qwuFV/EyYDd7Q4YAXgGCx1lLJUR/B2cu+pcy9VIA4QhDVtqug6IoP4t95WNOdx4fHHeBv9MVDd+Uc5BJDY0t5MPtD6SSzDg1xI+vmsAWee/nqN83RFd5U9UILs02+W/fnFBgZLOPbVsBjQr81WmdJov0hLMc3Sq2SY8tMw8kgLGqu6ndFU37K+HW3DM5n6koD95vZvARIberj6E5Ie/xTA94sRjIQKAdryGi46gWn8a/uQH27iuc4B0GNoPDYroN5cqBIXm0USE6k4GPiSHLxntdqCTV9gMhB/7ZsSy6uPblAcgKep+Ixl2/cdMS7syUd9DGHKRhZQ2I2AZViQhxVRkV1IFJ+zotLX/SZT328hUkrzELo6ZK8iQMAAY0BVoDKJ74ahI1WDUUQu/YQtwplMwZvipA6DfS6Kv0A/BdeLKLCI7nEwwDUeEsTJzGK9NklTdjTwQjGyRw0QAswJhRmm/aUV8RXL9ms4NYNlx7wfh+fK6gONcAYupmC6EEXkwagnFZHbdx0mrTT71riqGdpa83/+n/gReSznY2U/W7kaW7dWA0mFoiuPAg1CQYuO+tZDuaq4DtrAH2rT4dmXHvXNuou3LWTb1okqr4Tm0ebBLjeBLzqsecqyF6uVbIW2RdBdxdkz/VNu/LqC3ssKAGSDFV0zvucUnClO4VgWKTGfN0sdZZk2x5rKjU3cXgcB0ZyQPJU1rZ+qp0v5jTa4fX72ICnjdaX5OTPqzOZc5Etpl7W57iBT4tG/E945hRcKZR2PcwVwg42+j4GZcpEsOUQE92yRUN0nNh95dsvR7QwQYjEcAwNdAN9ctV0mIp8m5oq9krxhblbkbiNYOD63WPoVi0C3Ssgq14TCQETSr/BNbdpWSf8sHG29w1q7roN5hmITA2uzJeTtwGt7PCQummQeHEcVkcGBPlcuZTqXFl4WJ2TVCQUVq0XQrugTjI608m7Pawgu1vKKZDBDmfyg0368SohfBPEg6pApvgd8WzqxW/mgLMVde6b1m4ZapgHR8LEPyUu3+XYN8uWGjnWU8WkcxXR+b7BMlAjZ0R1vuz9wugZSrFkRt3DMKjgbmr2q1pvbDpCKGmnpCfdY8doMGwxX7GdSIrZSQ0ktxYEia5CYqnplK9fiw03RewK71AjOQy+7CvHMYaFV1ebRrE5QyYqTnbe8/KDKR2VTb9h64DRPApn3xlXdGUyXAMMtUpymvqe2KykLJfwcGrYW1WntWW0eRChNrHeGPxRruVeljN/0UYQcolqJwJxzbn1gLenLUfLUXiIS5tIBjZj4cj2QCcOYFI06U56CeXiKT6nk6ve6AGV5bMRHBNEDcfo7hmY0Jagkj2llMMVowcSo3Wrs2i8E2F/uf/TPVtb+tg7xDprDPUVmbddNocl5UNZbTY0Rxw4mmYIH86AbsPxLvAT5UHKqmW0olPXrCaBaz0sXHGWg2fYZSRijpV9T8Kz9v9KjUKPIwSHvehzXoM1yN4jm2kdnuUw7+v8/USadFJ7Qwd+ro544z3MEbx8uKha//Jw43Vo7JZoF5EAJcMbaVs5oZSZj5imGSNWzKSu2kH9Xrg1NTCZ0LuV33MMvHD+af2jygqYm2xdPBngsPyKhwmC7TZoT7ettx8y/Tor3YXqY4PPJpLgF6MsDUAcsMsmxXeOxcAjr+DU7/yOTCfKzCL7JzVvnNarrhy1JVZKx5QQRXKZwHY5e9sUBiQu0gSZA6g2GoCiUx6m/NCuEK2om8X95RpqyFfalOBnp+hvu4OlkqewkWitDdx9tS9lKD7oBCxOLirNXT4nOtoeAX7dgbA4JksvtF3MiLOR9QMAs8dGhAN+pRV96XGXBRO2Q6KoUpMRvAQuZwUlEsU0iOpmUwPNq+KFo0Elskx5v3jQ4iutskLobTV5EhaBRLTVLE0pDD7ZRPwObqPAch3G0a+Hhemcaqo6gI/botQe9KPhiZNEpH3cSLqdgHp/9SYN3XDUybDYst9/RWMN/Pd2mP7NB5GSKhQg2mtYyHtDNg11Jpc/OggG5gQtX67rSBSm3jJbtDRzbi44KJP3WvxRUpIEUBBnDje4GntwPdB91FH/cnoBJFTVpNHqrSJ7ZATe/OcNdkD8OjPN8l5/JjAjyi05dUjeg4uad56nTN3RpadMOsaijkA+qjTGlOVkSxEkinTr2xM8MrpbQ7lKw2Jni0GxsrNt1v8NJAje3bvB8qrYmeAW6UJBPVg7tE4gpNMgNqXNpZGAmMZJBCLM/kTcIdctfM1buCc0YpRTn4Nc3JIgLqh+tyR4OlHjuE6KJeZ8I+ZRlzLf8Yo3gete1jANoKEEMwgd2T1vjWltFP9PeR3n1oc3vfrSOnK4Q++82hYge0WLslm0g4xRTkYbPAHPzvGUpU7t/8P9DvPy8d6pQBvwnjyOhXa6MWdPViI/2GdxwdhvEIPZ20R5PHfJ172cVP2v47Z98VTeFq3jfkpsncZwYlr8uYsxJKw4Y0OT/JLkWPM3E7I+jeANZxwgxG7hBob/cLW5Gm6ePB8u5IR3p0KGR6JHN+p9UJ9MfkR2tEi7hte68Y7PObyfcCacTJD76VfXuLK/YhU2nmIQuH5MznubhQlHVBmQfASemW3dzoQdlwceDfRs+J1d8bvdYiuENlKEbfidIGx0Yf53Rlw5TqESrw68oX26lpO3qAjaxNlu+z8CwA/fw1WgmPdAl17BrwV72mlzbxbqhn0aa72dLI32epkpTGftfcB/OVR4NH2zGJInwFUJumBAltIqJEyLF1/x7Rd/ThR94B/u6EfybmxYwrf9uKFA8I/G9liKPy7YSpkwvc3sNJ8zb4Yqwm5C1IHH2hOOdJD3+N7CYK91AusiIIrapeO+RROcCYURn/bZFQTIhD1AFy33AkFzRz65iAuQwUnl7YkuPifVFwnosSGz5tKKPvzaUOn+opZzMDPLEdIa6LnFINAdssLq+2omriPrsz9AR5nyQhU+NE3sYU0eomPAi9K4VsKS0o1PvRL6DyuFVJ8jyb3Fv8EQ+WlDKfNoLs+QLezTtz299Yczf1z1bZgGwU0o9r+KctiO/6YD1OAy6oOsKDZSkFTrmSZVn427haCUHYFigaHPB/QoZG0oMN6QoYkNPMxMmHW1NwlHTRDMh4l8/AKA+XNYU9/KKiRamC/yWK24MXafeNax9cUOS6ay15g6gLPU7MbUogwr5LmuMap+8sG6rf3WYEgZ/GTKLfjLDvCUGkgyx1Llj/PppYZkuW8BF7GfsqloenKiFcZ1Jcqg0gNSjQBz0QoTCbvbRr5OZ5ZrV2qZepHLNOgywJRrkB5BWqij7tA5RyAfmCNp5IUzUYn65KgHqAWnKokc8FGoZxw8Xm92s+0GojKDDSTSZbMnPwv9C2jlLgHquA2ZtzgCM8mgM3UcPGjVE6wZHncI1apluW1jubnlJ4udbH8VItsPCqXt61DmMSbGuKfLca0JQuzWMxWGGw3LZYFQpGgqyCp49lnLVGpnkBbhLcFo6+wF5fUJSTbyffMRB8lQziJDlKQhna/wfbJSPD76L8ajKWz4BaZwbAEueXfmAMWf43q6hgmeFZcWPRMjrL3mK4BiYe47Gy93mLyfEfS9KvcJvSlUx7/LAV42N+mB9qmzdbpUdUQkofXpO32N6/3z2dT8mqlZVa9Yk1Aa4zLlIYzIds58LWn7/BkTe4mzapuN2w1f8JJoNxDwG2URqfUfkTNfIAtqOFRTS6yQBOrRLK5RWpAG5dSdzpwqUwczY3D8OgpS6wC8QC5TMTvsxorpjnejvS23kgAzLe02g7JyjHzaB+J4qfcUtpyMeQclZurhqzhlx5q3m5x32BCucERRxpsGHB79vgLCTwo6huu2g1Uo3XodRNEwZtF8fk3NxiLX5de5ARFH0LfrAlDlIwp3RcD0ld3XhaOHwK1bzyIgTdRUILCWtLlHzBy4+OmEopm5K3GMyREWDPVls6Ez9yeqXMI/MUv1rbpMeFjP/J57ziIn/JziqhFl3CMybIcfSDWB4myzYUl1rpk0r24olDqzXmBOgpP1KGq7wy2bbPhguowHgZm1iGSn1zoNM+HusN0nfmiKekXGLc26i6mOmsE1kKmLsLf8NFtbFyH1LtO+a1EYpOMiyC5fh+3NwuXYHwGuYfuIVAeHFy7xrAAkEaxDDWlu7stRrSd2zvkJ5WK574MtMjSW3KdMwTRTQFhK6u2ijWiplwJ/cSqNufjCCnXmO46wSky2kbnsQSDFOwxg076dzYlML6TnCvlcGq5zJ30OH5VWFaR5DqnQIJrOVo0o1Hvtzptz1lyWfUMmmEKjQvs+j0ZkOlp1V/FlTIy4snriaYAir+44R3Jy0hLh7KZl/474reS04XnsM5TIzT13uGEYPu4swyTT5sQLZGX/tz+QNDbEeWO3mm6aINoBL9su2YhwTo+tPBNwc0Sjf2u3247QGK0g/UajEJfFsB9RMk5B8L+Zm9fJV2Bv8Cn+AXAvmvk5x5GO9iYTqZjlvacVTdGLTWO2fyQoW+pROgro1s0PtLapk5ZKLnoX6f7F1YvHB8IJo68T2tAUwihxbOw+0xuBZDQYdhwb78CBxDB/obuV0MacBDzuEmEW1Wj2Oo+btVA6r5Js13eM7YEB4uFfdbds1VOlX5dgGXqKBWgMFUMw6BNSFKgPcq/UWfBK1OsWpr398nl5peOr+F0dcYWL7Ez/MEmrJdKklKURQQbjG6lqv/Itj3pSRhYZdONq2bCIR4gIqSi6U+2lq/hzYk6E16FO24NfLcV4IHFr9lqxhL4s6P4yQBsBe8+cE7T9Tl92bkBs7uMuFutemzPAg4ubpFVTBbis0FE3uQ2+9mBw3J8DnYc3m/qVWierjA3o3prutXYLCaA1RbrIR1d0ambUFXevd+OYFMWAPnQO10vPem1VG+1Cc+fYdLZJf5F42u8SPNksS6vn1Hr2hUxYn18RHSAPDKpQY9Y75HQOeqr5EwHCCOI85gxUerP03HsnwQWFTXKu9AltrMc3Zjrc8S/hKkIuHOfCvpMu7aBGiYJNBCshEN5uqKQipa8YasnVL/Qk3cWHkn7bXrD7Lt+4XTkDLJKsfLEg2enOIABQlfd2ZLlEfzKoe7Y8rv3OMkgnI8eHBuH0/OPyHE8j5AM2BqBCetO6GZgY8hh9BeYYKYzWh2xynEo2JmMceKhAy9/N2hBnFP73zjJ/TWKeJ2ZAS7HU4AcKs5kVL3M81J2sRLEkztT3td+fAjXVsJkAahpbEoQzfK4A3PXNqw4qQBpCnYYcsVktJZgUqgvdkS4UFWpGgGhbfRNPA8IJCFERC0goZNglvt3RH7ZpK5kVh/SqoBdhf9P277pz/FuqkIBP105OZalbLs5rqrGNs24Y//ibs8Etigi6eyxjgld9z/0Be3tgdXz49LBJCRP6/lzgZHYkFoc8Z4kOx2saQPcRdUf4SeX3+0lm5RTvRCa+yUVfri5Fn8fRGpnjQd4fFhiJPj+94N5TrsxDkybH2Egc6HS18ehsVOaos6C502JpG6brfzoej4/Wy8atNy1pFbR7IGrDjsvx/RsYheQ/MAcNpAAxmjljiR1NfiYYG8I6/IrC5ucObHI8/u7VV5i0nOojPFkMfhaJ2pUaNRT2CV8tt1zXtjp4kXfeAha9oa4gmMPPK8Otl2YPwkMsXPh4/qoUHZxufcrd0Pttu10SsRTjN1T83QMKEh1sh8brmascYdq1Qm0RiUR+oOVLqoqtFLgncMBK5v5FjKiZJ12heOPOroPY860i7PoeMtLFYcZi890XSp4sBw9gGEEH4TiYrE0GG/OIfn0ustqGXtXmYqYg2yP84xII+3QuRJ5HWCuyQIznTzOqEMqONbRb1MAgOcwH9kpV7RzZ5PlBeDg3QyF+TN2+3aumJ51Fl9MsBHqh3ZQiIVRrbyW09Th7/DRCK9nkdZg20VreyVPd4bp5PejRBxUtJMg17YsJ+tl2xiYw3/WV4canLDJvLjAwmENXOQNKps3TS6eAXUhkA57DjxmXoBDPltDwTNzNHgWADOCWxjYh304/pX1N18I/7RUXm7iultuDVBjo5PplRiN8cNLQd/Ddx1rz6V9TmbFHFhIGxiD/E4SZI9NioJkeFJaZ+uYNC7RMtQh17otBXsQblA8pam5OPs5hfqIyPXDqCSHgrpxpFyOACqDufNTypXXQQeTXsM44pbtCmVNISVMy/Z8KawFFzwGtt7Td8M16lnENz/R4I0MwxuWsfMaJn5EWxi3YMxXa66TBO0Ce75UXG0n0hI7qAHIQuzKVgNzwZ5LCmXojPVCOh5AouABL0GItCifVr4uTQkBjKbjxm7afKv8NY6nkWighJzDGBjhmOqJ2G6L7RJJkqnHtFiVw6/05pzhQ8IT8hGI1SuP6mueeUSpjwIMwwAjsDXRZXaF0CEijKKQc8/HqikUwK+2BZHoWcPgzRz+7c8R5qHTxQmYFStot4SsCbKAN6o03tQNmyrB4o1J6Pv4l7HmnSp/51icOPvemUrD/0t4llPEzcQufqx9VZJG3nip4hWrYva9HZTEXDx9LPOPeXsW/x2v6hRKvQzHzYfJo159MFo7uKeWJuflfnNrSjaLefYefmPJI5suo0XtKE6VXHAW3J4iUP3M0IgdIrn04hZRxX0k0f5GLNuOrIt8ZSrJPYrXk7FYnOp6QzuSVwYfx8vUIUvpthifWq1ncAa6JBeYZCgj0XVwuWSyIRKdMTxYW+9I7nhay4ZN2bHLiGwGafcx/rk3ZLOn/OP3NmjMVnWyFVTkPW5BSVMTodXMlBEI+H706p1/5o3dP82XDaNks/HIPWzBTvEQDdkqFLJ/RFi4JbZavsiKvzZUWUaErTrahqaNmMETp6lQiELBeao1s7fJYHR6ce1cHAV24Qw9v7/Oj90PIa5jbjj4aTpvyh++dXyBuiA0iMVV58EB8LXa1zb+6sUKRQF2buvzKYyCgXq7pOSyKr7GWecjmhlv6reHwIxnO7/sJFkqB1MxPxxl48nAXlKlmsDOFywDtTIqvyLkQgDFaKI1zKkJEg19o8GhE+jeREsPl3TdlHMM284/maYli/u4Mq+F0PNJQwP16AAzAENouGNHH8jkuq6z62dI3PYYMc2kHLga2vJAg+YwmeLYNVc/zQ8YvUFeCY+BZak5UU06zbMzMCnS4OBhMBXQH5e1xREl5alpysiq3P7fX67D6faCwmOUTL3ijbENczEo1hwSo/WWN1LeUvivlhlysq0IU6I+z8b5mCWZjJyStNLy4N78VAHerZ1IFbfj1+1m4jD5u1FaCukpoYpIkuPZa1V4+tUEU5PF9OSXKQVTOzbdt4GpkSkqKwQLhPf5yFUncewEThkk55DNuBWTz1qn2+iYvgbo0wE6qc4BOM1o/kkv2sETekBFV0UiiWWFc90peaTMoij18D2gnpq8CvyoI+JbMQnrbpHrZ7BBUaTSazFnoh8cwlXzNqNDp2oCfibcLJZJfYlXSHp7lquup8zXzbjRZ42PrPp2or3Bj/Rg/5JQoHErOuQ5TkFbLjhqAxat7nZ5xTqGH71MH3eRoNq619jLHHDgi/8tWF/u4eKqutkGBldEy3yzCTna9a9koVo/sZLsobiXrlSr3S63BXdUgDrSJOJ6oQ5hOdBndRdVFrMVG0fRHS3LRvmz1bUVMpCFI0X9x7AitbnqbOn3l6Vs+vojeVgYde4plhdBL9frx0iyootU/psggBLxa0KVSsIHKS/LOD3rz0Sw/aqJ8qU+BvipqAyTRWUkmqcmLWidF8YV/yPDaehYL/ORm6YWkT898VM297o7h7cXo/r9qLEPEKug/F1zdkeU5iCiY9FbIJkLPHMT+LmZtxxt0+LLNRu+HvKxN5MUu1vEie2SmRdvQ0b3/RUR4gjZ4GueoRRnqFzUPoD0IH8riS/Mk7qWmH9E4a7Vp1QWOzF9XP4lcnbezNLi5NZyD50EDNo/wDjDtE/b/dV9XopY6eyJZaPuGLnS/JOwWX8u7hbYoJoQIEVg5Fhgj5AWA+CF7VI2aB/3nlEPUpsDgKUKxvEV8AiJ1hk1wKg+udiIynyTWaEwyjyeb2s26mKH4fqyZbOFVESfSZizeeDGAHqZROdFPCHXKVUNZko14NAGv7uiSUlwK5IDTFLXI3x7sTJBn2tC5j1aIh78mGp+PSspZA2iajVnEHoii+SbI1WHa9bO9HyOSr0wB6Tk3zTVZ3Dd+xjuMiUQZGvKBZLAeEykiwsTNmhQB9rb3pwd9xuj4wnhzTOxAopQHksqlDkdYKEbinVqLgBQzDM1MRRBVvO4CzOyP19uGOHMPgiYv/A+cRSipvsxo8Y8UKyHTn8ZqRoRUUl9rVo15hUeAyqiwctizzdJsbGh5Jndx32ZImDVB3TGIla92KHK+MVv8I4IGKpo5kKEhd03kRCjEM9s19TfyR/MdlAbvbJB90bD+h9ep1K07G/r/Kro0yw+AXJc2iRZnn/oBwpoBGq41k80N0jITfL7RiBxw1E9hsynJYkot17cyklrS7gzWCznojKj39LfoiziBtGgLsJI7pFiKRGj0PLPEX4sZBJIALLyDuUG0Yd2/TQFiaCr/LRqYDzQKa8/wl2OANZ5b0b8tr2fudFB0Q13GvG3kz2E5srO7o89HnErJk71p4eHDqa9Eng/dsZIHpU4Xrss9QWiO5GBO+YXsCXzbVoxTMP0HdIdeUzomBtZIw88Kr/AyguIfqOYBxncFpqEnJU7Bm6eiAJz2rosXosiHtiosCYHim1tbO8/OfDWaLyAv0Xmth9pSQ7b96RjEx0N9N0l8/VpOMKg5RwaE0JNQ9/t5N/yQUYFd/1JiPpna3/xFjOPWay+Of4eCiLVF9eKma/nMwkz7f4otKQnWz4dQpcxQmbyphxhe/UzD/T3Zv7Hh5bdi1vjbeZoPvT8t/o8oIvy0j/2TvnG47uOFmnoHLJs+qNbRHcs93/n/9Bp00X/AUMhHfkiLxvKKj0l0HAiuBmj3FlqqRUIT5c7p/vCLbpiCzbe3zabqz9X+XrXdXJBfviDPNZFyfBM4GmUfSObHbF2oa0h67Tdrm6ntkciVNNbJrNnMVN5z9re657rA7sPQDlLYLzdCaNJEV3ua+ItGb1VQtJGeyVWihu3xZpVxAjTD4KnkKp9ZSC92ScuQnCwXM9yUCdOdySxdGffcem2C4NwnWu5Cq252bcKM9CTJKZUXFjUFJNjXWnpJ+bHep17iBeBAPIlZ3thkET2lbkdh2qDd7Rbgn99vwMBdj3HWIMSfNHb7hDQ8FATDUhSjMOfLAWidIurCW2ofILip51Ep1QrNX7HwUKKmYX26fhuqXcgMcdwdLiGWcnXZQ8k4aJZsBZO8HVTqXLdHtfKxdJVgHd5QNcakNa+5HT7Mt8MLVcdOqaXTctvvVUhcoQRxTuR4T1SRZuieJz2j74coTP6VAJH4g06Y7CQGwFU+yGYGwzP9mX777tWgfrbz4Jm+AS23wONijfBG5wuLSvxoCiMNVnGVHZSSr7ATvrbyU4dgTbTh4lXT097V3pEUQvRBshf3+oSHCWUIEPsFWBAIsnQtFOJYVxhbLsd+xIQk2mJrAbKRofjhD2arpNZdOhDg0Vkt90nkQL+wVYeXwnqENcmM3zyNAcGDLhmFhl1Y585WqXTjDszYQiPt4O3PQbWi26CivmnOVcf4f4/QsG6lwe/cRUT6WkxpTK4Ko0C8eGS4CitHFMDjRsNk+JS0rU8A66kGLTV+lYGrk5MgDjyY71Qmcs6uHbdQNnkD9tIIjzZR9SrU35S2B0al/fg6q6qzNgjPwVH7fuYuynbR7DBZdAqLDBKb7+PsVAS2otPSq6RRaTOXvRKYH2zDCT7+I/nFIZE8PQEPzQIljwqE4framj1PCEZ4wN6MoLwdAdLubEjuiJbjUp/9h2coE+I4bQfvmbozMF6MH2K5Dpp0hloQj7scJV3WeR2+K0OVadHM/a2v72bv4HgRPhkdTuBIg4xi6BIsdvR0L/aOWLq6OWmbcns6YtxeGqnCFkHTjGORZeIHARUsfFOU7jJU1zrn7rWhUGkfHNW27vuPGniMvTQtKcGuUW0CaL0HLmyBZcq7DWbumZkXXFOxBhiTfj6S6j6JFckWi3i22P6QNOOTiUz21sniLixe9+Fmfmte7wKvEz044/mssHDjsW0VAyPFs6HveNW+XuLcoUMmZij/9/2J6LAY0WOfmbPLBjYRNvZMOhbf+gc/viIWfp9n1ks5hSyvMEK9draaEkXEhyrVENdfzd/rX0/K2z0H19pipnVItJZCCHudDwfvuusZkBj/mOxpI5PA4SMENV931CdZS+m/FAIx37VY8O6alpBtEI/NodMflb7N9c/CBrkOFX9f2LCzurQMNKJS4TSIpd2sVlEvIN1GNvSGzfW9eV/ziKQr5PhRKxU9Dn3haunZ+v+AzPZWbegsrKm17+T4kkBI6KtcjRPr97ThkRPYUWFY5EGhbeqFUw+7DTePQQ70vPYMScaOBAvqY3DL7eFb5cFslz1c86evDJRYSjuwyhZnpax/bwoW4Jz3DPF0TOWKmbHz9z0Qb1Fh71EigxDKmAB0WwJTLeq1p+NMWT3jmDsF/eJ9vnn2dm/4i4buSNoUwnbgxh04NBqM1vK2+eecCFFx5wKk7HR18fV2k7PP4+DwfGZqD/UkE0obYrZ5sXFFCWAgFo++Shs5mrJXv6vkjDiRpUgqaKNXdg1UwSDxj767BwMorz0tK1UKFElEPnHIz2ALki3rP/OGuayIqzp3stXXA5s1kyZLrghFHsW9p/cRfu8UzmjcXJKZJnSU0bfts/CfOUP6h0l41a8iV4kkRQyTPwT694/XR401lq5MfLUdZGrdSlIDBD52M9pY3wi43AgWt0xa8II2mZIAF3YtOBiNt2FTe99gr/vaNrVrpA2Lgyg2OE50Xrw+RzKIZwUktHSEDkUz95RPxdoHiGShWthIuYzm0T6sCf0ZfQZ2417H72D4NqmxhuFm4d0kYbq1WVhr5AS6X10EWvoRPZHlruivxNY6RYnrmSlBL3Z+VLpdsQN00+pRkloExAwCkk6GU213GDWiUsZPwBx8NXpRlnFjdN+6V/oa7wzEcw0gVFBhNYWP55ZqCCMkM/OWOMNC/VnJ9+Y1XMcrPh6iXbGg5gUUOaZUY3GQvO7/4dUv2DcfNMMcPSesusQ+DjQbXQNij3h/Fd/n+SCAwEOI56tbZQx0xf2+toUq3bxxH4n5Aj0exJXs6wf7uthEk4UgnlB+skvqPjjPuXJwWKQZZ9hFyD4m5usPwhPPZkV2rY9BjkmnSkq+OUkwbanscWgLXouoLK3nkJ+UPA39UDaanfILVIjxKeur9LLZ6qlxgM7+C2mndQ70z3wFyeuythVpwGDfzk2DrOqIyX+ubMI2hGiDATvy2cARlKeGxYofV/0beDUl/LAAb1+qMeocsx7OTpHJzJF63QWXbU0VJMBLOgAB9nFTDVLLRh1ooGeOVFOqmxuCTq8lD3ptEGL4PyuFm3aifObY2TiKOYbq+WD5+EncgVDsqoFy4tP4fZSAx4PZXfYI8ekllhxMynEfBwOs07EIIZniLLI0RvFnirK0qf+IVQb+wJ3I0EjgfR6O5+jEE8EOtY1DKOw1fmnlYgkpAosGyubT/Ucczidob76dJpcbuwclw+8LXMAxYLcTUobK3OMCOw6LbO3I9iATG4IasQNgYmpWdjSdnlPXwyhb/cuJAWyrgbehUdzcDxouLyUS4nQ/2l0rngKXTUN7do0xfaXUvxvDFpwJ4N32Z2ouDcNXmy/AxgsArgqERUZC8G+1QttYRYk1pX6OUoFkrc2ZQY6lccOyHbz3xa9gIXFksRxU46mDMjggDtGOzoLe/SHKSE5bEOmkuceNRCUSKREh/+Ild/Cn/LO8UdL5ezAl7UcwtOb7wmXUCRM2lbLmokVXB+l0WqQdr6CCTOZxINqCV+oG3UzGOrkchkoz2RZlx7aHG7D+6sjcXRYkhcrCGfOijz896aFE5h1+iitrQzjyLCiAXgwbsSUHxQJxq1kkgYfe6Vh2FQSn90CwyeOYMMoDgMPlTDcJM1Um9X2YtxkSFGWi808JLKfRfG/nae8P8v0TPI/Hys/ZFPuxi/N20667kmzBJCJT/cirBXeBIs4JXkZ9I+mAPP2m72pzpC5lp83aBB90ioRCMJ0WtRRN5DYGbk1L94Ob+73RZHass09wd3b2Znzd4HRU8WWPb22My5397rli/kbD0P6Tp+3WELGsxTpASEVew10RRHSNMe5TXJ3UAIh9BJk7kO9PP+oUiUcMA0ekX+KRZD/jqQHXa87uu8cNsjdc515IFoEoZPEdr+v7F3P94flsi190OoCc5t8hVmibQbikOuU9nkIZCT20RpLtR1QPFyCF014/arV/HvSHRbbwwIY8PizBJtf9wAhuaTDLXfs6xVaQhxITQ40VXJpREwMFI9B6gYav+Al65KT3gCVtQIA2EhajgVr6V4Tzehig7MVyFWFheiZBMLC6jtoKNqHQ500opdOkxMUdfp3y6nHo4jBKSpF0yqamQtR2ruJVvgA2hKYf90zapLCcTgnK6C+QEXYB9RusZRjBvFHjegkLZLfwKyCb9mBLcdzPLR6lTr5hTy6RpFq9ZIelTxHnS8gjYh25zgUgAxl93ZkfM+yMQcq4isa41VDF6giiehvskJ0TQ1q2hRUnEtU9Mb0uFcBwcV5GHywuFS5S3ATxkAd/tTp7xgXs1TpRBgkCWQuDtNt3ZqIiloi+cdyqaLpLNWuxwq2TSg6D8KR2jJcq9oU+JXQQnoIyy57T6QQmUGOl37dXy1bOhLJ9MXEgKlv1e0PBRtSmS/ITOO/9tUhsxqj0Y1KNYcUBXvD7zWUDlD6bJEfZvn7u6LurU3q1j+d/02EpZXjX5bosMKxGwJBgzADxOjVGqVULt2X+XO9yIs2lh39i28BFaYXEOk/fJb39DcOpvYl+Y8OjyBEXX8QlEFjx5ww+nMUNpUPxHxw74/Sc32yKpLAn3cXQY2VtoffY5hT1oKUdGEIfUE3JZsNEV8hDZRkQ4ThGUSAl5K52FhfOBmiF7Cn3EP04JKH6zEvy5JQC8A7olZbxo2eeWT+s6kQOWYunBHsEzXLtHBzYeilSfbX1YsLnk6NT68TXkHwJoy5xcVSSGmD04ArgySyn+FUuc/CtPpdb7fSy7lKw9bf8qlEZ/PMeON8CfI5LPrIIO8WtpP0COgohVbB+ddlN2zMvde7jb8OHTClPaOWyOekLBUMNsApUJ6ovZFFU4dN/hf+A31FylyzxwURxSxBL93nztiWmcFaJWjkFYtvgc3ORr5qJ+UUUFLAJ+pX/cc0VdydepOgFAsj5HSmFeUnVXwzdNxFnry/F2/xcYwd0McG7iUUQAjSEEaRMjgt5V3Pd48j0oX2ay7K7vmlornGNtukMJolrQssVmK2his6+pzfat+PIcOuHRwiP1zd5gV+9svxABqJquJir/dSHF6FrOkGqtYEeIp1HBSF2eOkOjETejBHaB1hOkQtrQFMWvxKIz62cO9D4AuN++vTWgzx14xEuPowe5ki/s3RUWIYucZv6KHROqyw71VWfl5iQL0tvopd1kohmc7ag8AoW/I3vbEBdw8Vd+9jiQOhmHFdNsdNTkJM7TyQN5Yy9uCIGSucLhgvAZPPXdhWNi6frDAmaSIs7IpF7uL/Fss7cD0gZDm24QPAeKsZleO3irgAI4bMo5lxc7vmdnGZlAX+/usr8eOxxG6/0s3MwX9JZ3SRuZVmrZM+VK1uPTFkJYBS3fKJ+h1VgGetBqwz/R7/E/zQr4oHdQH4/5MLoQgN/Mp22UD6sKiIf5yOcbJ7Gl0mTCrxXfFll0Sl6hkhnvc+fpZd6IiozDOiWLto6LeCrdBx8AU/Fkruv6z/L/ScPvV7qtQZQuLfppHU4evQPtWvtgalGw1fZwBJAsw38A1uxeZY5XmlnNw+zIYeabK82VzRBtOqfCunfolvh1rFx9ps7AhYh7Eq3nRw8X0m7PatqaDrGz9woxf/KLrISBw3PKBAY46bTuu2S1NoxONetVKTHoWEAmPyqq2f2bNP8hML4nXfSOlcAGPSaMRFS91Ej6PXwEbovLygOHjykiVSM/RA1v/cpY+2RVa6310ioiSo1ZMSR90uF2tf6RBPDBNqGQrumSs3ZhKF3f2HTWd58VwR2N4O4zOAqOJFAQsSQdVysLG4LDm0bBZ/9R9RM7S/SmgTbSBRKMQyYf6XIz+FyujthJkvZfXe+97xI+0FrxtqW0/cq4cIJgSSFJVGD1Gfm/Wyv+8N9tR5HBgTMCf+00d3hac+qjjWEmYWyHxk9PqPs8bL5XPe+ekIAUlHtOGbICOT1nmlqo2gf7+djHiPwzCpCRC7LeXkz3kTYXzSoqysPS4JuzHA3fqhAIG2VMewUd6M5JCvEy3rZCpuv09ptOlOoy8Dv2qh8GjV2Kivi6KTFC0pTS7a3BlcDcPc/F7SdIl4uULS13VglJsXWNTU0LS7WpCiy0mnJI9w/0yGIqvL0PejDfCdhIY0iS86Le7b75DkWBnDWEWooS2fgsVCrxhy7Rlw4ey8pYByZS01vwblsGEoPvGOq5JJciECYj1ETszoZqr4/fniTPBsrXwom8YgeqfGnPPP7/f1BmQjIVpCmjMCs5AiqqWwanlJVs/zhAXYsU48ZqrdhBTL6CVGYDRFObOruZRjgPhjEr11rCbw/jvhKvLnleKjTTj1zw7oWfN13PEEzSDl/hIao1kp2CLJA5xJyok7mjfzzqBW0HA4cvwEdRGSQSh3OdPol010fTJDQ9G4g/jhELkxUIAjVKAzng2IC6tooMTjHRZinYj49tc8tqjSkeNP8AcY+c8S37tk0WOjcW4z+q0lq5Q532nlhBFUJ13UdrZ+9wJUh68uf0Ld6BXAxs8zqj3hr0YK1es2sYkC+Xzk3+qHJayMwQ62XtXO8yGhfhPvjy27rZwcfDUcflj1x8powRCB0guRCah/mZYZHjtfvlm3vC1GwGGqlSoTfKyQ+DjgnZ3yv+sOX4KXjpP2ZW3YyxrKRutZickVFAyU4isnBFHwbNgqbecZhwYFWOdgAR5iZu5yKkxJbAvsDrZOC1tML8R4boLf0VtJqSMe3IEBhwJOhiufzv9WyRbYlsXQ7h92GGx/tI+/pF33yJmFPsTNOREm5XVC/gimRCeYr/XnkwVDWRMGQC16kMW7FRcaOd8yo2PNC2EN/9gVtkYSyMf+9zGWLy78Mu3sxqQTC2/yzQ5qpR7HzPyTDtp9aDSJ+C2INYdMsrvUvfjXmySJaYM6QqrHAzPMaqy8vwnrivAUs6xmJEC0khi9nm2+uvuPuZLs2+AtOKcmQqWOyN5I1UrAfWBfEKe8VWMoIGNCdK3xj3FQeB7ursF2XISMPGg7LbNfldh0NY/AtUPGIWns9iKwbOPbBxzY02NMd+wzSg6mj6yxPmSqQAcjqaJKrcOdjldmTNDwPwv2xkOp9okS+4jWKQy1WutkydrW+9LmYZQg2vYDMH9SkOBF9YojQ1Vqm4GRmrbWJ5JGxjQHHjuup2nYeJ8RHLgKE5tmZdu7Gm+nTGwqsyg2dxpDh60c6+uVuQZPSj5i8r5s7hlgSbourAutTYHZvyPSJSCRHBG0+F9wRTetwo998Sa6Ktgp6JO12zp2ipTF4Ovb6N1ilM5uJljJTuB/JlPWu5vD5WXzUZ4WD0jMoULkC3mHmn34HSjVy9dB4KbCbHXI2xUIWP5Jgz1WFPjyv4ZnCytAwC6UfE5Yq/YYpkLlVe5EuZ/Id4thukwtyu0RUWDJt40mQDV6jZS+tBW6PkpBQn+ohahqJbdOiLQJFRUvFCDVJA3ewLaX7aOKiW0H5ZuZ06/Tfwk29Byg/wXNCxZ/1Qzm+VZr6/7D8+oTQp0zmHq2AZQr3998+66WZqUlsHHzqnpmX7h+2rEoB2JdM3ps7lu0W5cMSqKb4+lH9buJ/cZp5lTF4WVRlJnklyhjhnhU0Xvdn7dyFbrrEaeHUND+ip1ddFnaC1SxeRT0lJgFyeMlc9BDiXgymIjEAde14ERQmYn8Ft5Kd/osRnIg4SSA8/Xl6s8sNGiwbSq1aSKYBNIYMNRaCP+RBAtNiIzQV9ffn0DLkrXocLde1ofEzxXOkyCScLTHCj1lEdptqb/IIliMsf2RstTvf3stypwya1wHt7/x+DXjFImuGXqMuZZfsu7UNAPhOchUwhwMKJoW0l0hx2M/puW+owWVfypPy9jcD+KqtczFsG9SWik5ZPnGOw4uA10gUt488aRaBkbHm9XzOgLjU7bOluaYyPHLyU2M9+WRqVUAJrS5SHVro1hdlg6dgfXlFfAef35qt1El/NEFYuFdKVPkslaOfgCFpwCNrKDGHgr/hLMC0CrKifIi74A8iPCltVoweeZ/KwW1E06Fq4ouzA32F3vd38301F2XxowNaz889VIwXv5I9AsWCLMSatMqECrz7ut1R55+Ynv4iSkUGGD6ZAQfFI5OhFHBvfK3NTI9B9H38dkCbUaS2nhxUwghnXCloUQHr1T1ZYEIZISBE4HNJtRGsMxCuT99LZ9y1G+BYx1c2GRGPID/lmYbyAYDmyBcM7EJDigxJUhaAANmO0WSDRZ+xZZt/+xzRSI6U4685/y1dAvvSr/LqsfOI/s9uQbMXAxRHVVaSScUZ+SvMxROZkkSSkL2j1xXXNioUPv/U+o220bEtjidWT9tZuTnD2tSvMb7GbnrMVCNiBg+rbMbpUDXDFEjjnvhzIXJZa/rmUf5DyxbwYk6OprRqCo3j1NXPd8jcX5R2NdXkdHHknodoSyiija7C9TVI7Ox7uuOkmt+4J68iD2mU+j1tFtgQrIiZV628Y+fl3bZcP631cFlUmaB+Fr3hwL9aD5vstXYKw66aLlAAfUm3lJym5MeqsFJWZNGT7FWZs1N0ZSD4IAlCvfGo6zC6wsp53qb3YREBM+xsQuHgWt9f5wRrQw+rqy0Ur3A9MeG1Il6FNjYV+uT5kwhCRjV+su8QfBKB6yUnKJys7L6kYb8+9Cvdu3k2nJne7PUrv6dxeVSN7BNQJDcgyf+4Aj7k13dNxJV5ie+e6eBIaGhfH1v3GQvfq86Vazw6eLWZdt+geC1IMmyRPOin7avie3memu+3N8WdyPVX4JBwa/B0neXVDqLFxl6gmAZugJUWL/uD6BXqCXeSdzJ8p6z4doiCtlMF0Hf2b3XVvoJCkIeC6ueBVTOii62UB4wtkM27CLeQMxsCe5er1cuMQA4GBKfyO8FFlWTkfqNzs/OX1OfPPRUrPwUavuWMx4CWtAdJ2a224NDRT/JwVXQ4HH9k5jGH+k1T41mhAPVyK+XRaq7cyux7iN4+2etVZpgAB2QMGRDOI9+zu0zGFk+d6tFNgynq3Q7VR7F061BnPV7iX0HaszDqkfMNA36p4klqPyln8Zs7jIx3jBkFTmfjDtPDNKw+58GrveewOL4WIvSWEsKt/dIgkOHhDTe3xKefb8DUjPgGFpE8llUfTPZC5qiiLhOEnDZ+Oo6ENNevRRa5g8cpO+eseLCc5cYkBpWE1IdAy0WtJCYOrOh3aXSwRGJ3P8tRxYZWAYR+33ZF6JrP/QOB9TUAWYvmnxocktsJGyp0YIZvHb9WjXNrIdtpNczpPJFTEvyKNnaIczet+h1d8sMToeWD78plBgLnxGUa23Hp9biC+l4Xl5auWr5P5H1jSv1WrhYpkpoScRED9K6ZJZeUKYHtH80TmfVsEQhysKmnPeBdVuvei8t+p6pw6Iq/aUeYob37k/QMNkUUCjrCrimvgQlXT3Y2y2ZCgbND7Iw0zXRIJuoHvzpObyjC9QVdYAV6vUMLro+XdDrHvOO/Krd41CzyEAVCcRe8r3fcSH4WRX4cZeVyE/Q4UWdrMMHw5CMhlUsnt9YYehYsujUfFGL9bvJ6q/zdCSWljgkC76jI2f5ZjEm56tnz2s7w9/ewphvPsATYVaIE389UjQAf1Yj7EXNE93U4706QDOJ5vULetSrAm6Y2r254o/GPqt8askZoSQuEHSd88lpXFYXLk1RSmrQXY3NKCG1DRM0wC3iZJLLDEo83813JT6rWnC3MGvgBml2Kz6TSwd1v4qAvIfWTHBWgmiWrXBc8d8PIYwzykdtCzc1GEQ7aXSDnfxpWDEvMcXcoiOTnEr1G6/bvEaUWhrPrzEEeGcNYqcVbhyx/U1FpUVzRIYyC272thqmbx6gCiGAlf6bhBGkFp28DCmyHAd6kPCecREejMtHOzNDptU8MX1Kdx9jfJL2cXtuxFhgFuRcGOFtN2Zm3j+62h4KCTC24fIIEDgCd3sDgykoEm9zIPrSUyj9B1NzHc32D0Wp5hK10XGJ4bdcJXJRDBGxT3pPm5mZZ98FAV6b52fRaiRBi7r8Tnx9XGKLYuiJmNdI6L4VAMF5h16YgTtfW6y2a3RaWuROWfxqqpEBd4xmr07lrZ6PwIrMwtOKW1QqCUrUBjou12199Vu/Dsc89joFEU0gRD4MOD3nrhzTxTuamSwPY/auKoY2IW2s9KyJVd5qG2ji7uQfKyNCHY0hWTSZ+y+OKWKKtV/LiYHreqrrH84F/OI3gjFyxc+35NVciySAS1Ckn+bsHYR6c6qMPbGrqav4IsX3mddbyDPCR/hyGLo0wTpHmAUuXfUrv0M9H6rErAty0/EeAuJ4IQVjVDYGL0Z1dxpq1ohcYMb87Dv/lf4te22Fp66to3dlLbHcct3UOeYnlhYa3KYmuYUnhl7TOQ383jIFwtQXzWz2nNbo7qlgNOfZkaG27AgckHOt/rOa8RLvZZIbpodnMvIsdPrp+04wDmsAq5attj/Ib77NCni3r6kY3I3ThOCJWHPXKSezc2gBpn14kD3Q4QfPB8uilAUEawSHmGBo7bTok5YuqJhI/98dtjIoaozQV3E6hWtRBtwjdcvFY0EaeUpRe8puiDGM6B64lVRPq6CmMx7ZkX73nF3SnLY17NW2jhQCitCCjxSsyuJtHi/R2YBW0M0NPMltw96hGZ9dbasszxYX3C3I7vQc5l353nT5QuEwLbPTJdx8orgejf41Q1W1TJ5rG8otBJg4jra3/VlY3ujrp85I98iUi1AlYmv9LERF4k5sEbNZhNnJ+Uj0OWYkai9xOeMIoRNE8ni7yCXusqLsxA8/1bJ/74NtCdhBxLY7Uyi/MdTSH0vfxPEZ+QPSpiCHVpMUMF93gabo7k55NI07PNhijrkfU3srg4saKfMPZAhlgUua+13quzAexHViLMqIdsjI47rDYHIWwkUPBIWdZouaBUyTlyWb1dFAXAKkY/09hazDHVdDuem+VVsQBur1nLQjFz0e+ovm9DjYEv8WceLaXMDZS0dVE238A4v52k2OU9nig/ejzQCZ4VOe4arO1hllKfz4sccVy68cRhy39dElDespaHPfweceWX5JkT/NJ9wfVwZkidEuhDhhy54D15wimcLash2aDupyEjBybfND9cuTkYxfzfb1nice4KKT8eRtUziTQsF2X3vRy1/yOG3dopL/rDexSX0HPaCWKjU9JJQs4vpl9Bu+84wsuVASc9NOzt8E9/reKDkyUcwgXNsfu5RnjefNJhv4rEQ2Wr4IGukr1LKSurGkty+71Sg6kluBfjZtGa/kg1zLMsuZGOw6Y9Wy+RUCNdea9nURLlDAjxiM6HkhtPuC8BQCq+60GbbktjBrqinCvEJox2NJEGcr99wr6znZtePeQdVmM3Xxv4ef7XdyvDM+0qH/MO9HRblW1NLrQ3G74xEW0nFqQ58FcU7TMJbEQ67ZgWZsIQzO3osEbJ/shcGxBsqvmuBYK/3tqUkw6CSP5kKbm0qiOR3aMnGFh+n8tg8m3XCCtmgyZwgD8aIZMcsyoV3R/aojC2/vyzaupJUGn5fktoGqaTlKF67u8VPwlYoOC2Lt6mfrrI/y44mn+7mMpvagHM9elGRPbSlkLnquyxxS2/tp43w3klp6PXMIaTbVnnB8OTOYzr0hA1eIIjg2yNNkBjeJMrHw8uCTzfFSkMNf8XrmMOWyeiHSzOEFElBJVxdnTT76g2r1N4U/tqOKgsSRICJ0+IPK9RXgRqHY3vzgQNCbkciKHO8uR8UYmQ6h0U3lbC1/T6s2tRVasa/ygrSYGtiQ6rPDAETGYxFwYkHPWJexTrKUTF6wK8dKpq4+BoLjJgXaT03H2s/lrvNgFpg532uU+0dLr/UJihkeIXTw/B5TtCtfxFdwXrISzSlwwmM/x2sxoMSKBBN1YzxGGP7oc4jF0uJL5YUYc94bO07a+rKYm3rZHpaqwwjWqw13izHYlq1kJhKWaC4RmTA3E6lp2qo4XE16Z5iHZEabIjb/aaXWTAy5NCQUWQI/xz4EH/VmkmIX6BSfmJDhMN04HbrQ38kpUk1PgqfS2jI5JLs8JoPsQySpijtfu+x9Ku25nIKcvfSyxCUvIG3qzZDJjp4O0k5qb3CzDUOhc3qUiUxbcxcSGozarz3UABtoxQqvx8/HET4qaDDNxQdn1wGkAgrNH5kZe9NkRqo3QheJTV47iOEd4L7KBcxjWWL2XOf09PHDbWul807dJZS8eTxR/svRIfqpm39BzAY05WckunDRXQB3i+RTug15haxsjSp8Z1pteZG8V69yKPNuQ8ZeaucFYA/fsMLpgfA5LVpEzBvBo6QRBpygYPZGXcy3cn0diV4WriY4l8QyRPTwbXp0UJezg8abFE66kSmxr+fGD5RBX0cGJatn7D5pb/VoOIrrN0VG16GystpsINiYm0WWBcOM1n7iA6ssKZDPpBGQsAzvWTH0akl9ZWWo/AAt/lGzAv9jhBQwOHXtnEGuMl1JM2tQEd1ZXDtcTXRPOqKn8EUA3Afn2WQsOlvCpjZRI/+tahH7MoVHstDHmSqhDDh2+EEsGBmt6cZXYn252TlretI/RnYYQ5DrLV2CAd8qvI5Kpc1Sv5qqDaaj9O0Zro8kgGqsfxjJNJP6sDyOfvFChBZfNioCO2VflAU3hdsr7NHMbkCwuObSA9jPmFa1S9iQiyJ9SCKynkiHVAFDYMintN5D++eiKD7ySmOueOb+6AABOtLax5GJMApI1PRBN5EqCv9GKPvlqw4Mj1hFHYBYr7GcVUdhVkL+ROWpZYbXHvn/ZHc1HgDy6BlOAMlJOq0Iynd1cAM7H4rX9F+x/+7O5asbcPeRvYtgm4ULBdk220UwOoUf2bk+iXuZSqj3LKkiP76HhyFhQ4SQN9fhORpgERI+35gLu5xkKJ1W8n1oP26vVtLckElW4we1qLVUO0Bie23G/XiroGwkitD2xpHXQdmY/Gw4+dci3riK8ZGC4cjpCRYQR3dy/H71b3+SyePYzpE/p29hfJn7/wzlseq1g4rFe0jvDERF4lSYNGoJx01mDQE+FsOEKlv1yYm7qw55GCYMEuI6ffbBS3o/4k7z7pyRV593C+U01W7hkqU2BZQyT3RnXc65wvwXLHpEE57URLq0rdA4hR2S73TpMpZSlMZL/BiF10V21vCiWtNbE8mwcOJ6VGs7DnvW+VRby9m9Wu2tAp1E5WZ/38t3ajMC4HTNyFDFZ7unUXzOVdBQnVFQlew2aOHB/iZwjKvkfsNbMAM8qKwspBC9mFR6bE4EF37xEgXNCr2zkOkzXUqSlzkRmWqJqnTSBrA3LhhdVJnXFa+dQ9EToLQ6gYns9382IIBiGCeItRoO/h/y1Y7T3/TWrOAnyRcvnOMm9ZjTr5nFOak8GPbSS3jsk09njSvHS8CcI4w1ntdvh6rnHNfl+sdkUMA/CAFlrgDXHYekTdexDVdrh3j3zHhnZO8GGRFwwLUDZ1kb6sAl1ZpoS3y4lfm9K3EKpNmD2Adxj0p/Qkphj3cDiEvRF7Gek9Qpcmvul0KKhhHFza3r4T+cK73vkjEGbAT2iIqTIWOOPkR6gLO2kMjVN7NGxnmz5iwQ5x+nlbBsoJqeNU6PXz4Bc1v6gPkfCqzcUgP4ZCn09l/zK5srnhveb+rm9oOgj6jQvgpg3RlWNY7PB95AH94ilvrgnE1jEywfPABqS0+fz7RVqBlabQJmaS/MZwkwjI9La9jRXj5BSfUtUZHsmzu1QOn8AZijTiUBovL7/j4M6cWcFvBCAWM5ChrlI2rijWuNIGOsRnNWogsQ4H/pkpLoP3FGce+HYSWhoUdAzBsEA61P8eKOIyju7C/P03ZuCiWvwCImqjs0AtczRsWWgjPfmsVA3IzgsiCGxogijhEx1y2iqs66+BW73HbniXF+KrZ/5eWQ9jYodL1vQCDUGCISOed3HAsA2SZaN6y7U7i9D/X6YMEa6PwD6zck7Ud+xIr4DIcx2dAJgI58wxqBOtJY82urWIgO46qdrdQfAPUmQmve0tDHTXPhJT2C1BYrdLenREPYep4nupVQuj66qNDPi+zq6qvsJjqNq8pfUi2EB4n47NtHJlD4zmWr1JRbe1FJ1fueNeui6QJ4kwVAwsAdl9RaPzN9yk3chnukbOdTZm9eyqCBRQbI3NKz+bzbkDsoqQrt8LHtSHsv2eZAXHQXLmGWYOw1iZ7lqd952paMQUMw9ajR6hXsuOgE9SQuUnwZMwnU/Zp4Fai5W6btstSwmOGE2m/1AJ7rfFcX7YNMtdtMsTVxhRCpqzEJgkddMsK+stIoN2GLHyotINtXYL2vK5aT1K427Jq4v6muYSYfzry4KsiLS8LwRjID57/13q6d0FfIyYigF2AOlB05+dXvu2dNBMrvsSdmVnGN26LhgGqB8d2pohUrt7xb5a9qH6FeKrvSXgVm6iCjDOt4NUsrAl1ObjTh36T4jR+jbNXUotK1wosobrE9KyraTL4AQXd11Ozzsq7u8xY0Zzmy2zDEbg68/IH2fmNmSONjFY9GTE8mTL+yJD+9i2qnzASm3yK+7qdcRNwx89Om6g8PjCioGq+X3ZueOWbJ3/C9YP5cVIBFEyG0AeuEnCDU2BK2Nba+mWiQNqlIC3wSYv7us8ALoZzl7GQR7nLrjiUNlPrwFNbKI82XR9GmxZ7XCnUqhSK90oAUotZ3tPqlNCV7u06xSXu7A/ayZk1mng7RhQ4ytnAjd+BlwW/gSVqVBI7jegkehL63Xxwbivcz4AYJkVVTM9QgfDXe/ap1M6ocgETv0JwMQzvx+nOwzfUCH57qt0lGQ+ve430T7EvKBJgDbv+fCbQtOpB8T391PytLHXlyVr6toBFRNZ+nTIymilhw/fzBzBkydPWi6fueD75ug7CoFhqdL/WbfbGM+IC77m6NFcLRt4sURIKpNFifRXFg2v0yvkSEu5DmCUb3PK2Uk/fMEtWWRYfSkWhm9IrM87fXVlr1wJ6uOuFgU9fvRzJ/03HdAIJoP54BfEhAH8Qr7jsr9YvVEKDNAmsX/x+Q6PTtFKTMRqLywqcgH0I+4zJjXDgMGBLcXo3xsNb81Db/rcoF3w8dwRijlaweZ/T0J0dTCsYQvj3jw9/fFBTFlakDTml/79OIneMDTJ+VXZQQ8Cs59GhMGnnVtH26jaM+BQy3CGTaPrxCLmHdzq6HdnQ0BDirgOk9Gh0rrX7hrv6LmpaMMJcoLXGRGBMVOqcj8hr9YzL8nufT00jcnOL5Dl+Y3nyr5PK3a2di/4ECtn4XlREL0bB9H+Dn/uB3nsOm8bj+Rg4oJkxKQXzDX9DYlZK4i90e4l2Oo/dhkrZt5+rFQay4Ug596fZDFvRtGfEwJnUbSkNYvl7tG34qKwwqbpFRvgddHY7Bp7Lq9dwIucs12d0cP+V4M2AmN5RyUw+T7188p4q4AISduVkvzDB9uEMLBeLbGlaGCww4D0261roa/kzwIZLJT3ZIc4G4A+QUf2l4qTWcR66PPlC40XpKKGfYi0yxciThAJlrYnc9oZbpQ/5xToxf92p+LZShJBx4dOi2t5fsqCYOBt3MWtFhKpol/kTGhYGEGcD7Gl0E9xYGFMkxEaxwEimQk9VXr5gOkF2OZuh0Mn2Tu856o/WXyCcUIYXIb8uGcctNIteeoHW3Dgz0nqmCBlB0P/UIf3RTqm3GNQhTTYzEy5uVAYrNbXLz15U+Pftq2XotZ8twuLiQT5iA4PHXy6ABv6Gea2TJ3jUI7y6i9UhhmChqhbyWekDeuPw9w1D8qhbMeTBD38A0RilhzUeqr9BDYO+oSudyAqMHDQh7RghCP3wcyHZUYv6WOv1/5cHyX/XcdHZZKBLkPpA862X2thbysCeYhafW5TFhIB0Ew419gQzsTy6TgeU+ypx5zOb6Ss+LQRSp5a/1zSBHoHznYiYmRaqYcjkBYOtz7pCLMS0IHE/t2FTKrVnfSrOFkA3b1xF/ynld6ORWqQIV+e1joNAjCT09DyLK2Sh0eofaO8bCvcp6HPhjEUz+0HKP3KplOAPq/Qt1M6VtMZs5akZAq0VbXGlhZvuTvW1Z3SFZZt1kO2zZ6xGyLYnSL1JOtMJGNmbW3d4pYLBfQcqt7GnZRcRSAti77h5PDk8z9sWBDUaHIGBfbPGugtvmdQvuTGdlt9WHVFNTX+uMOFK6Tia59xL4VaAnxwJusIporlguYdLzPQf65YJ29GDh90HvroxQizRJ32jYjeI/u+KicqhvJqGrBCvayEg0dY9wY8xG9jOwNJNSboZypCpJVUA2b4JskSEX5tBeE1mkwfiH8w0Dde98ATAKOFOjYhDRusIkEGPk4PX6qN6jog/cXB66pFl7lwJBgAHqOyH7OoKolbEaRf4NjnTJgmYL8YNg3Evc17bMjFRuui83J2d+auATjdj98aMxQrbh+Y/vvz76EpuDQZl5+co7SJcmAyAII0Pxo9GjDZ7C7IimVV/i0VEgIUp28nRPD3Pff+2b+tVe5jDXSwWCaLKCWWrELe3AHQ8t9vIjdJj158/18oKofFNlS2XVyBmZ7tmqvRzeR3nqI1mRFkKFKIwozR+JjpYjJVs4CoNkN9Ni9rAvR4Tr3ZTY7iR+5S+Cx74SaXB6DIfvEzjBKjf09mc8Ojne4eksiEhu5ffcMZ6Cv42P6zy0Y3ISCLbqcsEmVfkT1LL2xfN1TWKDGmR0ByQJMvEMUzf+A3msmv3RjPWGmWnokk+KjSPzswgZT+pfc/zxbgJJ7tRuZ0QzZzZkLEhrhA0eq+wX3Tv7VbWYu+qcQnwwwPaDetNt1LVKxN6/PzUOxuYic1dHsZSZy7r38miYeHWYiP9gSVSNJx1uXqI2npj0P1AgEfBbQg/m2otWPWigSB6ZQkIWOhUg4fhBNyuWv5M28p+xzzTebzl8kE8AxBDzKyv0jWGI+bXLPrUoIW4UCQZD97xphwTvKi0z6lJvjdSzlNwsceReo7EIbFq0q59cMiqXOiqsVBixBsUue9faidMhDCotgPpoqaN+Nvbqv8RHJDJfpQ+Kl5IjYp2nH6rPxLciuUlulKqZ0YhLrLEh0rDMcg6y0AZzMtPlVc9QYpMdyXe8tmrqIE8iOfcWfuS46eepmqcTcrHm6otl2KZeW8jO4s4Sf37/2xwJHLj5yagJ4DPbMASZraV394hR0U2Och+TczBQ0kWjSxwQt1Jf5jwb/rdD5jYL2pO0GBNWDXnutN7art9LkqSqmDP46opxrHK6akO5aT2UIfyy1Z81dOy+RtsDBLWWz7yxRayfqrwtsMOVMaBgnZ8+V5Fc4NAVUaG1ausFx+d2+4Po7XKGuyAYTXzHUuq80uORJLjRfGsQbVyuWvZEeEnOS2kEgm6w5r09Ebbb6v4FPRq+tVY2d7Kzz1hkFHmmaxcM1tmyuMhFAJn7Vv1TBF2TGVhyvB6zZ3+7HOsyWYpeC8ZYSOZFD/DXVH92ZUa2GMyXzGQNM6vdvPK7WMI0V2Rbi5OP6BqlxJWlz6x+wskRCMQRS2kotcYfjFvNAzw81n/AZAoE+vueZjwbbfMwGTb/wdlSO8FDATNmqdvSKQkcUVbjHnAmHTPf9/Tk6Qmin8f8BA/2ZQYwMTBnA6m8oErSC0DQc2O2kn85uOJ/NCWYziqUE4OO5kTFCSzul4iZIvgaNHyn+nh61cMl+HOiLAJyUj3T8uzoQYCsQ09abhxTDfLjDaBBSB2CU6yc3ATcgN5a2FjAEgmPJiFeBFXpNlSbG3HuhBKU8LxT0APPe9cxTU00HC6jOro/Th5KytIAiMQyuaEkZk94Vy70Z33+mhc5FW4oN8R8CIBoYbr9FVnKZevUoiP3Ff+JUvWeQ1p9dPQascNB9CYkqxJvQioLWd93QmaGg/D+rblZjvTtyO9npbFP9eiLArlX3IFI9PthzwnIYsA6hucOz28n/NbyCDJv1pFK6xt9xZZP6JgKP/F85BRfQrclicxTVdLHOaolIcUAOcQJ0vXp9aiNPG6FbvkkKjGG1D8JQ9ffhBtCG6DVTQyDvtLUUhiHWHjwL45NjNmNEqNQK3DrWAYoto5GS0KBjSxkrBAwiwdXP11de6YODYVVZYPsq1WEeIPGZRilZ48yGRFPFCA7R5zFTr57NVYXeL+mMXPEogUjItfSMMLe673nZAZOuY9xjMYxXiev8v/nCsFV5kh/uvHHGQfF12/hayx/rgM/JSLvfU/ETCoR6sooNb1NjqBdWzyzOY1rC6FhxxlCVGgbiOV+bw3+u0LDvA2733syComOpUTgrM20XTSI5hGX9GuJDGkavzj6GwQUsAyIcKQLruXtXK4xUnAHD/Lu4D9u7mBWcA65tRhWxa53YJgfqnIBjQVZ4jVH/X4Mazwnd3AbWFuPkPwumglUZ+gL4Q2GZG8cfTKAdQzWJH2C7HcW8q+QaGK23yP7BtSAY+Yl1wyXbeQamHGwJ+Y6NYxH5UsVg1oMIzi+DUpZG5NK+ZOgozDaISCZTx9IaeN7hLDjOJ3PaaoGaByHphPsDtB0FGNSA6NsjwLphzhF9u7ym5wE38L3a/Yqq84srfAnaLt0aDyb2CyxhvZoJW2jTmZxeRljoc0LPugI60e+/DppR+SosZU1u/jZfTjsDs65zkCAu+Sn/ERkvSb1omv1Fp8E0lPI+XnJ/hmO+BSFLhrPR8vP0Cop0DbaSrB++uzBNJ16VgUFtdevJ6j1NP5cJ5khItNQGq5JWGzkCPCpJ7uonUrgWzuJB0sKqvKxPJc6TX8DZCSit3JpnZm9FfdV0EANiW6ABJ9362E5ddJf3y+E3i2SdR3AibZrkx2kUoYSmiqwVLDZKfou2ZjKn4Ou+zjiF8gDuZNy/cpAHHDjh/U3Pi8NiVRoyp64QqY9xxFcN0Ct5/RoCi1pkGbeeVkJulvoNmLWOKalCsFKDPbk2DX+1H81EgBKVMTCjsDpGFjbEtDZx5xOPTHIhaGk68iqJfUwcpLmxnW8kLe3v8D/F9vmZ6D2NgRJL+26THGS6wBm9+veptwe8AabCwuE+hqXIrJ5TkMu60ukoQV5vfH43hvgKDHBiccfdVmkc8ikxEj1+NLKeuV0MnQJPtgyBaTzmXACEsfhI2DRzxdRIXNRBsSc0696uWZxsR9UNVoWZWpAHXKfkWFsO5ynnyMmCQXCG/tNQraQt8NOUSoQbKpgzZGG4rKgCLBo8W1pdJpHyjarVfX58yV7KZ+VlKeIharKv+ybBXgAG4rwxlnbD5iWZvH6AaSkwajFlSca2gbJqRhLgWds5MrHAvxXc3vryj/hHNTEcRb3X7D1g7mujodvQqEM8kB+/6Oyeu82aEZU6QQx0SMp6LL9CSCSt+FExoOZmLx/bXzZ6uajOSUc0aUWZRwkeO6fU54CAKE7SAxXirsPwxq03x7crDrwC8GKAirNhfyvI1LpGEkajDB8MP/pquj1A8EOXhsCc+pbL1sjcGPlmqGShYMgZfkQYNbfMeC8BQm4kPN5UZICU17lIjhoCEq6sRBux90P4VCy6vWIjV0cGKKgiN1Q2y5aJVmMdnGsPzNkUt9TPud9Csxb7E+rjLV3EcSNx25EdHSu83KwpE9p/23yBBARRSmrLRQCFu+6cKNucPeJrIUwMM6WJwyjSIliiNQLTK2lj8O1G9keBtM7mv6y4Erx965JQC6EVgkRqcY8X6oBLsPBgHfpThngMF6K1Ht4b1TW6rDRxCzoOB3ecDw10iI9f2dxCj8rmnXHfW5oTM4SaM5kzsQWlXsi9DYvFh4kbHTGZ3vCbF5FU7NOwUR+ZZ9YYlmvklO7XWmbYGhIqt1YTHgDkBttLqd16A4iAR5gvV7oYFeFcWTINyj56pWIlaRmSHvgaAFufurzHfp93Weh2mfxKFMh+DLdEGpPeF2XYIUoR0VVX0AayFoSh+5oiPCoMdXyr3ZY+CI3jxhS2cViNFuEudOLcdR1kZ0flP1sezxfbh2admjA05e6ovfwhnfH9q3EfDI8Lv1FlOAz+YdVpPae5WYQFT/f0bS3GCuZGAgPriw2+xpbSUN4REWARkigV+FfRBJ/eiKTESvn5wdMEKzqgeGZZS9x9S79oXRHAnTKAJX7UWgKmyGaKViM6JDQHIYuDc+RNkf8yszMurg7UOJSRJVEa2zq8vHwkoKHqhKHfBQN9HSVlPfD9akTPkDK6Tr+L1BBAKQ8jDS4/pivAT+9XZBwYRkdKLAsq4ph4JcKdf+8hvtDDQXkz2iEDxYMduWrb+D69BB0Bhbx81nbGoHj0UBzPITPERiGEPSozyrJKLpy94U/1GwWZ0sUUqZ4XWr6pnVPXU5tXEjEATMNOORkB8Bk32THamRShQlk8cOA9mNCk8XsW7Oqj7WxPawRL8MVy8ZEVSan0dO/NHxfzZ3q3mG+Rb7g/zE1EZSHZAF9oA3w2kFnzWCPWTf87dF7ofeP82z3QD2B7Rn6Qrj8kqSq2U+PXXZGmglr+cJ0lczl3KvAg+a8DMSC2HRG86xjja4r95/kosg6K1sLDFT1nLMHa08eQokwI1tUSbE/WxAiHYWfxaAlObYPfZ3+6khB6wQqVdBd3y6Yp1wif1uFX+z4u+RunpX9xygntfgbH09X+GLUGA8i9Wh1pUZlPrD4hJ2tJ2eg16znGIixWNILcI2kFiDXqBox5f6zIWuIy2uk4Qy0hVd3Dei9S0wPMwtdj42s5L/3Q/vRA+kSPpdhYhZW61awjFbTFV1wh6nZDZ2CQuncRvT5U3YBPY9m82Qm5URzuRT15PcvDguN289LGOprHP+D1yvHu6WSazduXbVtSL/ttDNSIstt21WLly0ifmKa5D77GHzK4uNwnNDKwP83jemSuClDLfpv92DHVwWSoZNN2g1cRYPRyxHEh4w9gW8vOtU0NDviRQPM2FYK5Ta2vV73ap9JDBr8SesnVQk/yTx4F+tMWx5tR7O/7w0ROAoVYoaiiNOhiltBHVFOzkqfr9dASbHcjCJkTb+46tf55JF21QHl7p5n36KLuUrRJepNfQv1hVvIgUCTtcnAungeCbFKsUrJyGrYVXeaMHDYOfsKmaY+xkwMfrlo2BbWIlgzvoOijJKsZsohUeWLQhybbItmOqRzMHO7F5bQV4rrpjo507Bj1bvPp8TuR/LH/xFZvj6J2oKZ1Vnsh6XN0VeKnw8y8eZvQeEIAqu6nVF090RduQtZ+sVQ149pEvd2Pn42VGwMrhhpJ/hKcPjnx6VA1qqOGr4b54tEHEfqipsjsr1ENCju3sSMQcpCmgxNrYjWs6CTAzpzq1GpF0tgpgxm9C+h1VeUUwBvcAFgo2lkXfsvy38cBIdpKgDy/C06BHHBzHnJnBxhqi3LGh2mWbpi7LvArUprxrjJQxaekRDpYpA5MljX8DMYULzqWLBjM4zPMS1dUxIj7p+G1CziMxeqyxnkSdsYhFkWRKNux8GSXc+cVwiZ8hevbMe3zEHmDLWgu4qj3QlR7Vst8Ch6V1g0jyw0GpCEjNpzMXTcite7DfxX9Us4eZFOpILgAxD95WW2m4uP0fmkKt9YZIkj53J3BCb/YWGJei7WdyuzmlmeGNq7RIyD0kJ96NIB0hQAonRCxz98R1SdAGTqTP6UJ2JK+zGpz59cku7QOalGeWJHPNGmH8J7uN/oM8p4S7aBU+gyDGwUgGILeaJNTDb7TD7Br2OyR07pPawFnRxTJ6cZdL8p9VNsRL6WC+9DM/DnXAmsp+e1xMR33okxbR7Z7zoSBM/2WvKscnRAU9KV73V3c/yLMW1z1dcEaz60EwfSV0SWLMgG3O8kAR8S/8IsIg6xAB3Ntu+oib5gy9HwDNVg82kbGnyr0ml9Lz7H+yL6nr13HGNBJ4Lerxxt+KZVuSuIrnVnF+Z21J6WOvrrtVUGalrRyiThYmZafciJPFScjk4spCsCb8hp/687vV9/qRFwd3hc8WAWkHx+j88tywuU1j44fkO9Z9uB9P84tmGSILNsQyJKfSjm2nyNKFj8640hay09sEzX6n3PUJOQWJqOUlXYZXo9CHSKqb3/qiV1wjt+fQa24mVvsukCexwNuBvVsp1hkKcj0R/ybPgHxj5DwNiv1VnlZEZgBVo4XTDrYwIc1ghdEG0lzLV2YERvb+XMTCVDsXk7xApOb+QpNt3i8tGWULaUY6cBohdiHoJJnSM44N/Ny/yw7ZNWYAJM5cmAtIzzNIlLcIrCPg5OudgeQxhGi44YM93vACn9bCcxt933gKulwFBtDGxfpQSKq6JWRyCiRGnZDnnhHVhcQz4/Y+lGydKXoszC7/d9EJLqRsKSWcmSIkZL9OgzXNgL0E2WipQseJ01p+KDYke8Lnu23Iz36/Qr5Z3kIan5BnrXji3HWN5J+wsbIxWs9nlWjcjhJGpXFrvg2pyChp5+Ooa9RYku0p0onpxQAZRrl4BZhbdQaNDzFGyt2NK9wzwQ+FxhNCMMk29GxGVyajWnn0u9RjC2Ag8ipWc0Lrj1Rh248aRYRElrQGgQ9oKCljej0+oYoFkTpJY3XzfP9I5m5RjSrgVCoYHp0YMghOiKClJ4gpjsHa/vTPX6cFiqi8kuDSrtfczseUyhHONGyWH+ydvuX3+22ajrXzRHLAY9PLfQrnSuUxBku2uYB6noWucX5IlPSqDnsC96iZBoFoL4bTkjnkm3eJWu4F4280xOGTLO5dTyywvbfX95y2asqcSDwRIUlEtNqb7Bjwds5GoXpDgi1WbHb97F8Ecrs5xFQkON6R6E08PxIVXFB5k/IyY5Zd8LmAaepXim3+MlLX03eAylmCNKGPhh0JRRUJAII9vtvk/ncMwoGtkUBDdXAjOtJ9cfnshGzuGNpsCgyiMXpg7/0dORahFVg1gViyi4d175+x+cLqTm0dXqFSvmXV68xklDQfe49UlvVlk4Fp17vY5PLb7SCYsrvn2qtUrqUf1SpBbjUkAMxINy1MM2rz3ExaELf9NuWAqaquUWPDb9wwb4u33smk7u8tSgBxOPcwD4GDauM/Be+7G+MRDhg/V3FdgkuvSpcCLpOcwZcKqm4pbgTUk7AIEZcdUGeKizP4oTmZPF9r3da1cb9r7KEetMhcFAgwb7cUdXMn3/mvNRBY9XtVU1cX5bawtacpbzUiDU4YIkAB/V2GpJZXSdrENq93cv5qKnnt8KgkI01MqsnLoCm9NnTNoo4pHIP1WooATjtEbokWaPs0kMx+BVfazZrnj+7f6vXnqNiWPrrXuq64cHfcC30O47iHrQSO0RCO7WfVHmJMFjg4ph+etQt9BMvQGysCTqgSrD/qGgPDB6WRkPxW5xeIxycV+M4JEqClJ+sfHvHmb/myDMW7JFLGS2A1mBfyTCmXDjffFKziKZzvQyylL37m544/FxxOTt9ckG0QSQHIcAkPx1ZL0daOeW4kQGcGQCiUi33D73mmhTLGSqMo9v00qnZVM/66fl1RFgpjthzZEmfFjWh2N4j1ZNIjwFXdcE2C7UrzPi3h184TN5vLQfdLDdBqf2AN6p+VudmBIJN4VLSxetX1vz2JrcKMpxeIMXzIzeRDCfx9z/ilKl3IufO+gma7PELzfzKYIlDOq+Q+iYHJ7eI5+1C1Eu+6ZXxn8TZKn8CgY/LeOk9Pwy4u7TMdXwT2rT5C8lT0shK+qNmLMpolAOwAkIVAc+0xrTdt/eAYI4vS3M1sHwSy/lRAzjCSh5PAC9Pz39BEeKtpz+Y70TpBcVrLY7fBi2rZfFcLRmmTzsegAU2VGwigF+CYT58ciHOh/gWT+N5+5xrzlCSgabLCUehLCIf/GCIs3a+09Nyj635CCC877OMjJ6XT3CMu6Phy7J4YxxxZAGNYmzaM7OTt45QBoauLobzi40rBLF6QlERMudhvw9H03sR20SiTKs9o1zr++ifp9yPcyAQ/54GrPFH6J+YqQKTpXe2FOx+ITAG2XyDM5BvKHjJmsZUwOj7Sw8ltXH+q7eoZXhd3UON7QyDeXoyGGZTLm2sGkPxArWM/MyztzPdN8HCzYmIGVYLfYXMLShI0Xvq1znsdRB21eo6EmSYLcUS4aCjxdD4m436om5ujbjnTIxCWfDbYrUg73yl+FJtlaroaJPNlVb0KXQYKuoBfFD03fNce/rGIJ7eVKMQmaBK+AUO7fZ+QW9MZr2YocMSgxb1Oxm6/Ak/myQV5kPCoBlm7atbzALfKH66DeLnjFrxvB8Jh0LBcayX1/0g9mSUhb6DjsUpV2AO1+VzSATSMVd/8x4EKdpNSWAd3g2vozrbrQBfAlUjV7YR0+L2ZsmCAXjf9R2D3+SvLf9MyBGjvAU4TtgZeL7tQZeuRNCWb/zDv0sCGxH4ceUT/N/O46ps68lTUnzC33nl3DsfbiOUnO/yfWswLUKIPEsPJGpcFwSzo/2J0wsSpyjKZlgFNyT2PNheO0EfjjeZ8q6cj68S6QDQSSMnjAdFb0wVxOJLrER9kIJMR9hIo29EgJLRUr/52cW9pZlHW6tdupRpv4vJmAHK4C5IkQHvhn3r5lcuuQDDQkG0AdFitK+9VKwC/EI4Ml+Rn+fsf+1xV+FJ6PhVh16wiEqNsN/Ot50aeMOAfku/ybbyHen2/2zaIBbdEywyLHeIVgS1Vmm9iHfVIQT5Evxhqb60TQ6+KYS8QdzKmyXKC4pFJVk5ad6jgKNWk4mlgBmSIp9NWoxKN3kUWtKTTa7Ks1OzMRyb2aBOR07rEJogFhsk1pO4MARJBiCYB4UfEZTWhqaeQFpF1ux9+SKZKpqLacEpHA2SeiU/NOZi4HbW4daBrswF8mbFpKi1xoYcUZqUrRUN13/mrsZe6sCB60qCUkBU3tYYTkLJiPG1Zhkj2CdO+s+0jSLtTEUQGsreHoT2QlorVLzbaPRXX3Db4nSPCpBs7rIHwbP9jSgx6monGtx6c2a4R/xB1YrrzMvKbjUNJZAu9Uoh2k4KMlTr+CCZqtILmAVQtTzFPbstFVGvCCfRDbcXD9XV/WX/VEz02Gjcfu5JIsn/4tgGLNm7pJxqyJmgPnQHIFIvGrY0pUsmRr7RRDoFYRfLUGlocbTuMxCjEY1m3hDer4GNnjChWwHCKahJ8kkbn6vH5IQlnrfPhGV/H6CZo0pZ1z0SEjq7EhRn24yt613E6C5SvojZLOR/SyjXKSakLBQa22e338n8NDkZdtbHffQ0wyWteMK8vsD63M14IMo1awFeimxIL5eT/FMV0i6geVkbuv7Gn1HguxCDJNXdjFy+fVv75POUiFYfl0O9jgbOVBovRz6FShAOmjpnEMtWIhb4A0bXUkvEcYTcSNNbF9GBQIbO8mv8cfeR/QikFmDvDhf3VBYSQOCZiL7WbBsKUHf1KQasa4Lv9M4wBV2wFrNuTvt3Z+IQExFh9aajUhIC4hM38Q7ibe4SpXAmE29uELdonFjs78WMpg/6m7ifHUPbs89d2Lh+hIvJovDAwI9l8e6SYmU32FMR6/jGP1NqT0NrGr6OZNWeOFcYboul6Xa8K+KnkAmIxm9ZzkXMSNDq6LVKqpbRlsq8bYtKn77H4jgODBNOMBCXmbrHvuV6iHUjUdJXUdNPrNuDWBqF+5w3DjhpIHDt+2Ml5R1DEgDydklHXng/bqORWHzjbkfKy/UqMEhz80GLX59TCAfI1xiN/SokquD2tcYGp7hTOm8ZyZd+iGSjHCE36M3mhO3wy9v8REE/rrmU0FobhYY1tS3ilOLCpVUN/LAD7wqKa0znUEz1J2yRNaFB7Q2b8vC8hHHKzu2rq4NUqS1WY/E6bRYAqlzVQjqIYte+wD9k8dokEqkDFthZa3frwgWGe4xdbRTv1c20SWYWqU4R3SQKEZlCwNqZoTfJT8nAUPlOnaDjFyNtjbrTuA1lCWBzPEH8L5DJbbgbUXzKWLeyVkfA8ZYT2TZS/TpkV0HgC2Iy24S1vHW6S6KZWLyU95RD8GX0BYQ2DOhlCmDhHTgjyx6eNu86xedFxXTnKBZopdTRBzafKvDHxN7hGrYPl0erf8t0UpS6iYoRfcChGIlr7v1KwJxB2H0pAscqMuFZcXDNxFH6cItMrCN6BqX02ILyw39/cldKGO7XhW9ceeaUm15TKYmA3jLplawFktZPwz1BidMSGx9IuVtMiwomx9dM8kEg2cvmM5C6XtVIFsL6gC2RanPD5IjFWqaECYrenmrhZwu6qoJq6Jdd7Xun6GrnGi8SG34uutyLWIlxDZ83BnUzEzSo1deHWU0UQHTX42/eIjCCJcn5fK76miBrTy+GPqXtpMl+qzJ3s69e/UXYOhRIVjFRK5WjUwx+3uWikXekZd3Sm71BRCkV/AMgEhtT0ih5tpwtURSqf2Hb6SlrHlUFvZ4lk+9Fg01ACZvycjZ5urJNFZe09KWz2ybmunniF/P90cNs9gU5Zcv5yUaR/1VPwQuCvaTxeLUW+0qEIMwWC4iOGL61bTOAP74DmA0qRuNTULBQisd8ANhdh9syTZTkfBZrJjDZFd9laufzdm7LNglp5bdlKEMFJpDBC3k8Tg3dMCoOpLw1Gp06b83ISICS9eCzxMReN7Yv3aTtDFTIbWIiW20j6byVyd4KRtNkUt0of5VYny62N9TwDl8BdZl/pjTW+QThXtgUNyJghWvz9ksM8U1XYr5ib8BeyZULFS1PINyH2wv9Y8G/Bvb/bMOakBHM+Vq5iaLy3bemzpH7gyKtU/mru2WrtNpizcvYtdsmhzhd5yAqFmXoxlPBt2is8SWmGTt5Hwo/WTBIPGIGmrJ0w/s8CZQllEDUQWI9XS3PNolCe1Z24JuEGYbKCAP6N0RBLyM9v8HRIxtHhU77tr2QZLcOfyjjmFLUfOWzY5yjqHkQg0npt0RoLK8kFX1EtsCrJQGgngfFuxadCyOcnY7Py/zI5vlcbwSGMraNoCVWNa9+SaR6mWDMyA9P/fmZtldTLFu2RSW9ecQK/oOxtPkdOJhtEnqhgeNOcdXPCq98ouvoE44Bu7CN4zopXGiihjn+E89HM4bLp06J60fZqVqe5R2eeimauPcWUP6j9alsyQl517C+C3r3rqhlGjeBLbVL8hHRe8cQJJPrIVa6a4P808NBSclIXiiyPFhQWsrMFdKUq8aBXJrQ1CXzpH83tvoHFpo1G1+3NOe2Hki+SxswcLBTTr02l1PbMDDh9Ikixk3NmYFACTTBytHR6ckPMM1AYmLDqdKD+a6LwyhpFK/PLCG+uW6DWZh5sBBXFZgpj+k/u5dM1vqa/wvyquQI1Y1isMpcEC8D/K063t+wabgnjEgvLuoRjV67OXyOgFRSZC94UlnttviJbYAiuSgMCidpmnA9zuO7fMxYRaa3nYD8EoEEe3s5GW/s7nisKz10Lich7e7I3IkcC2ttPaeT40baVChnmHNUdPKF9lf65J8fp/zbFQj7+eARIYorgXYW8V9p1I+gJHSLd+JPMQJecc5iM4sFybTXs/GhCxWXuzJwym+veHYPsm93WSfzbVjTxTxz2iO4poJupAMzDY+SZsO0i4IwicCH8Iq2TVfw3psNrd6g8Ds//WaCg2qqyRrKdDwZtiMNo6ekbkGPvegnazTkBTadgsN0VYA8Wi6hYND4X5f7XU/mXttEMQxxLZhz5JPCI2kKgIFPYb60WjH04ZM6xCGLuPjE6USKClbAbfHzvEsLUrLt09HXl7EFiNlBJoruVLfctnsCmgXi0ztZGGiA4q81+2kPeeuy45VEkkRKLsrY8Aca0mrmMJYI+A2W/DcKHSiBCFbqk19sjqCPWjmNhe5Fz4A0rc40jpQyzg4DW5SPDnw62bVJsfr4RrYfMEpJp24monAjNlm99bFKXdPwcwJQt3IKyYthSmzF863xrCI1UiKqNqX7ke8YcTlU7O4sCMthiGB3/EslTUuBXBWK6Gck1hmRpOumMQvFMdNewQsMTY2X3N9GNsb6cEnpNtdUo60O5Ezb1Fi0GLS21tRITiEyoNdj5bxXkv/J6jboKJLUl4/lXFAni/APKoalAyIDm9Lx7uC+ApLUaNwSDs98WU015vgCS8hdl8OB4F/WsjL6G6VW8EmEL43mLl7DTcNYQZ8NoJZIy7/m2nAQhwUcef3ob0KwftgOuOEp9ECQk0CIJHCH7uPan0WKLUXJ+mnvp8zW/F5NoM4V+uVF1vi1p0aLnPyZ2VMchVpBxdEDOIOWReoILxJbfNmIiobZjXllZ9qX3OtKjorYX0zU9dQRu2aZkaMhTuG6NhrP9RS9vDxyAXoW2PIPZFJcrp4zWkuu3xABqqetPFueg+EjxPFKTSQ67aTtlcIzgPyKquBTX8POSdwyefyhstwMM+dBXe9tB+YtbPvPMBWOGSFJX9VzO48QRUCDDQwGYTlknWxZyXoi4gUVpQzkIprm1Nv8ztdFbe33MOhFHiNEh1p28Y73qx8KaNigRmcdd/ZVrAqdkUZCHBYhQY/9AVOpOpFKa4uMVWRl7hU1lO/98Qsb7RY6xz0fSo0zsNWZ0IqQkzdh6Ev0dvoktbUIOYalbm37LUnT1P0Rdopjh0f7Awo/3oZY3TiCGNJwDyFLFpdi7Sxt31lQkhH0qhlzHr2H0PQjttFEi0Wq9KioDOPJY1IR5TJ0dJ5448TQ7NjnVkN7IXQg0DSEuCmd83KELMChEQ1qJrW/CBZDhLXIBRKjCqnI3VD9GF7pn5qshSxAXRaBc+iDp9MlbRbRq1kVgyO272N0Hi6iucYo1ZFwsgNSMbZP6ftIZSO+DtluWa4ozX/P0MWyLAsl5IZchORMakTju3z8BufO/hS2QTPLUb/hHS9QeK3LlKULymEdH6pNAvU52+HxvmSUXfAb3h+92TxNU/HltQy6FnNBPn/9J75cSjm4Q9/U9jipkSQ5g0DD4hGdnGv29OqQQY7z+4QSwjRifsN5F5sWGrulBwy7M+hwlClecIKMauH9yPk+QfPBEu5BW4si5gOU4VsKQ1uuc+AyCck51BGzsDq6fOl7hbbcWlR9h5sE4SAOe1bNo37IPkHgc1L+ZcO6vt+2aX1xB+F9XPMN8GOzC1xyComCEe692T2IHuYlSAxAjP1URyAL4/GC2sL8+Pp/Bnnu9aiGVWjzXREGAp+6FN8DCxAou/Lm1r4Bzg3kG5SgXpgJBe4wXK3SnDWJhN2WnMsCl0AJsyLyX0RbnjP5vNHtEnCfILdbnHKA0aB/FKoEqet6VAYwnEAQPUze40WI6IdErrh5teyvCBwuGjwc61g2NL0gVzWHoFSOXI9aWyB0Yc6anb6TXazwjFxEkHgJeWUAYKbhsOYL0Vzt6jc6NLR0anJaTnxE+OD5YN+42aAGxXWUBLxZNn86bCVcTQz/AYZxlR/pLc1lFozcFby4A5PT5xTX5NU6XQMj8e1R/Tb7bP2kyWaEi7/ADxziU9Qo6dV334ZQm/zGor7fIDEFab0Bn4Tua27+2XujTrGqHPgZPTi4Y07lGTyQsExi9qtiQLaP+LvlLK9JGymR6tICPLOw0gzHAbyCSmbgf5fNsaDNtog4B7h3hcV8KtqV7dw5w3Iqc92hBNEP0OqQidAVm7dIfOHmsFjGiflyGKQwKTXluu4c4AwDAGd2Nm9IzFjCygEPDJbitOijq7BQP0UatBYR6onM2vY5L7o04gOw1Z6ctTVHkH6t7fFxlBfnuwLLcYee6KaeIggrmn+c9c0k3gNHrDJWGfbzWMrvWyvZpi5u7R0vMUZykvUHvtJv4oSe+v1qB1izA4SHv2AzG9s8lUkbprdBrPjqRr6Anfdzfocr+zKD6/HDPQ0ChwsfmkC06ZkJOesC9gXEKhTQStVZbbKvFqHc6ofw6xgGXXthqU2pfb2TbMbKoIO4jvME7M+B7q+xXvaX88pR7CPELupNhNWEkNAiFerHyfJDqfAC4YPo8pQLx8aGOcs2QsfCJdtY3zdAcU04sAOoOwAlJpaqHURtXn66pGENm/GCISNagMlWw77B4R/WN/1BaQmIIu+Sr4F+xaphqJ1mi5W/tDLUVPe965wq0GtMzNpR9M3Y+BcaHTwCyNnW3wjPXKWNNkIxvxqVEJio5WnLVhqWnfEBgaQlArHPyeAvu2rJKpvzUAAjtdOBMzNLy7+onem2OJcLHW9AlnuJeZvGK92ZzGkhC0D4NBkHmcHW+7ElVk0vO7OZ6fnmpEc0bR131g8M78+gAa0ZCwr/6ix2i10JWA26AV8eZ88oOmEbulGFWigGqhH2CBKJkGgaC5uYnza73HPyPFPb3rYzYNQ8CqMYdrcsCYqqDfSRI3WGGRaWkA5walmwt43VgFkQVKjYYuV0jx3GE78wWkQ30IlXfYPPpDiHgdUkIlk2xjWsm5SeFmVk/E7xTnA4UDVqZqjYeyaxGZ1GvuyW1RFu2dvOqId4dZbMEvB1gGkqYKr/k1zb2MbddyvwNUMc2ysQyRuW4iBYzPpl1d8freIfXEDFcNPanC0Dk1Vsee1jGnkLjEbEMMC46LDX8FAoyOEoQJz5gZuuGCyr81Dna2W+7FzfjyS/DZUnnMv86+HMarG81OzboD/nn9tQZkllcU5eis+SDbYEDXb3QF1nbS2vbOuosuDPTdhIRFBWtJwMJgF+9IgISUh9XNwicc9HG6OLPYt5KM3TfHwvJHgxwm3MDS9Qb0YylXqkkgpF3gw1A5zHAiuDcD5YUEjrgS0z7e9lDVFi11LbUHYJzwCpWmEO0DJz2mf4pwJ0V/gbeiRNXBiCsrCIbnJzkW0dPY9nRJ5sGRiCkhvtw9yQ6Duhn8fmCqgHh+vvEHmInzpf6DGgVorXykHNZO7IK0YmAOXhLX5zbuONF0uHxp/w8lOkqiUExNLSkSX9egh7s803mJ+4Iekv8lJfMFmr6KEqaZ0WbJzw7SeMQubRd1Pkrs+4/Ee8Z2Fv5oh9gs1/tMhqYh2cXyuIp4OXkwZFlGIBi1hxuuhPDGIL9Et9vi+H0l587FfVedgWG+FJDFL3VOgnpek7ZY+IuOcl6uppE6CLp837lAxxsXI97D51lEhkv96bjAfz4hoG3HZLZT6tcuCCEVQ/i3tIjbMZCtH/Cr+K2S+DM9s1afKGl6asgrsC6eATb0enjBXxenejln5ukxzT4k9eeUHpT4fwxaYthE/98xn06BEvJ/2iDe/xtbDo9iMbg0sz/RHuQIGvwa+nUEROrejBJe9WCH9fS6n/aGVe22F4NSkrgLX3QlaDapp6cz5MhILk6dOD9WhdvvIzdydAcpGn14UAou1AXys5u8MB/bV2rqUrNxpunEyV5/Xws0ainbbcua4PeZsnrVMuP6yCEvLb2FOmCm96ssRHgJ6sjuZdmdvwZ1jAzsbs1BbAIi+3vWv9QCvYrVD5AinkWmS3iKlKQXlAetywQFoPR36ugfMrRgWiVqZ5CNn6lw0zXYiQVBKsHB2SZ3Ikf2b4H9AFb7rjpZI+IGF11WFSc19L6tqD+wDzzEXDA+CfkwK2UTYKAfJZIoF0kZAgoofc0fjKyhKCZ53keZqWy21Ks4uoi0DBXODJc4YdW9xPePC3BheGha9/XWby5iUdicSuVOcDGt69EPTc+LHVVrWsDczOFpjV8Le9c9jU98o0Bg6QImii+Uw6xioHauz1Bfj2Q/P6HRYNlYkNL+awpgswv7J5v0H/rv6uKDL3aNxUYMPPQLHDQi4zqk5oD4h87pvTWeFsgOWhxn8qLUnp84ze3+7hp4JXQl8kLK6/C+/hlvZMKWKtvIuWtGM54vloEv5LZK7RZKShwer/vqApq5E+zy/zTTrW6L2mua7wqsyX1PCi5zDC6tMZB9QiceobcwC6f36JOa1di4fZFb8P6iOFPW339qE8m6q+djiZaawrYfYHS46bX/FjLf7HfZJYrHFb/J/jYUcLpfylXPhKyLuEH0bOiuPK7UOv6p4L4vFyZXHLfkW4C0atJcZbJvYnLaZN+KKHyo18Md+fOGMrdxN1uBMGuXgBxoOvn1wMU3tIkDTBRO37K1KG7mN6T2NDI5DKTxcfLdk4PO3Gx4ydqdcQ1KDFhF+90UH74Sa/Hr8RcXvr86bTztlf7Ga+f2I3ypWMJhavq3KWNYSFji2gT2SuW9vvwsNdNsviVs7Hj5eKPtlG6EKG18jllWhXa3Ild9qpwxo9y7MopM0V1rvlXAI8dCK3wydd6t8BhMiU7spTw5RYS1z2e6ASK9rs+PD2dHp5b/pivng5qo/MxLZYsOe4Ip6Hb3um5dIvLZwIaILZtu4ic1y8I6PMJh3mS0/Xc2BxRv4MxAcVI478Jzys+jq9L4MKpS4zvJKq9Gfdi/ORS9OXPtqEtCJIyztF9lm4Jw5hBLqHQYC95+JeHGTtm1W7ykFcjhCEnsjJY82nmN6+ZaooX4SnG12T8UanWYin5GOFN0beNpy5TKsQyAc5Qk8AIlYBsGiLtmzH775lWM0Ay6SatpWaN4wyfXJyMN4s9D81sspir/Wt9A6gINyk/JiRSSaJhGtJgNAWAHj5wFbUChODbWzRRRs74fjhBlOr07p5ZcmPQuuETMFN2R7u9k5D6MNArztUxAZ6XJJBHuF6VRjef77e/3iFKSdRECy0K866RlUDE59fqYP4DvlB0QLDO4PJFbpIAqJV8c1zOP02bA1CRXNooA5rxYEnXiaVS1XilervkNDd3MwtINirNI4oVhngMejgBNy5ZRD+Utk7qPJY4o/xbqVbunpSUFhY3OtCGxN1yOsMEAvSyRLBITv15nBp6O4G858hMSGm1RUhVqzCncCLOYCu7wa3mJoY/uGnkY7sbgOnKCQ/oLK9Ip8t+srUuV+KnQNE9uU4EE657+w6TzjOiIKaCACgeNhyeZw1MiKKcANyoYJTUA/I/xve4re40NByPBIxPlVahqV1+W+uDycsAoVIl4YtTBiCIlXBXM9gidua23W7gEzCBBDQVLZZwpXq4QrPlzLlxT0UydOadB5C4XSbi5el/zKcuXpa2NSExyHwb4np+Jlj/BZJFM25Zw44SEuDYQ01Qz+D/S4/Wreeq6PKCIztFv+pTkOlksui/ZwdiiBZw9NKyKIfif2s3mbVA4B2vscfAQ4yFg5wfv5/j8rshQiBR57ulkmnnJ93vW18nkS0jrfXjZkITiEOisUXXSv0YTGo82/RimOXdSb8BSG8CrwYU9KdhkAWd0fdL9s7jYcqfNNBdPNFdDgRsy/Q0AWAxKZcmXhCle7oj1INrf7zLw26WHVp1ulKxdn9aV1DGwbN39PfvPEKU3YffTN0SRZBuWLtyBO5ZOQ5fC7VQeBRIjQ2ZsCySaZl0ZQYUxLpe6ZsWvAWjwkJzjZDXA9nWz6ApQgKKp/fhlO4qQ5GBw+ieEGP2EDekUUDSu09YxcgGk9fu+DZeIniQ5Ukz/LKhXk/uBwFGeXL9uiwkMW2lE+y2Mdc1M+TauZQnZc6ZPrXnlvfQ0qVFiO3RyLIO4Ya2lacNQmA6iCMrSWaxigl8KUgLzybhMtmGlwEKJ3jMWsm6Wdz0UGKO8qKf1m4K+/4PCuhAlRmbvcLe7gSjfaOqYoQsAJGUDEQiwgT71e+gjfKtNpIN3PHqMAk38Hk3Kmrcqq5/k/oIxn5cI6ihxFq3bFAdJB2S4W2bSdSysBdxdQx8VQU3LoW0Sm1+tGJ5kcENrNRsAUqzU+ElK4RqFYiXhSBxaQQ8YoUrjrjXa604g/fuSnOCGOct12jfXNlDH8WgWscegtYnYKkS6Lcqi2XmLC3CgoNZ+qWwdt1iDbXums334WrrdbAyQuT8DBLua+BJ8jwJ/gcEeplG+i5Ck6+FLYSHgCbC/xSGqkXE9pCUdPbFR35hLCnCCNRLafAE9ykeM7ZNbj6nd4ASW9NWPUvfUXzRBlGNl1DIUtvRJzR3O1mf2jVBQ6jo5zA/nNtKifIUQ/R9MxCRQ8zPGYEohxUfVz8uDpPplKdZUTDeubCKmopkUmNliCNPZDZ+/v5FGM7WbS2U9VBBRF9YKGKK1k/1kfYWfINRiJFhbSq9lLK8jt6wBtYR/y9XSX0wmnFG+oG904QfJpVhABheVJhZC7Gm2skQ7ZRuSWhj8d3knDViz/Fj4Oo4i3nYiyEY4gPmY2iQ7bOUIgo/G4DHLnu+CQa0pv3IaLHRV+gqrR2LloWjLTm0lWGtW/v4Y96wPGK5WWD0ZqjRp06mlIkjumvhhfLHjvOiItsegyuVr1xDqXj+z/BHwhBRpwDaxbI2A7BvP1Br0AcSmragUKZZOcG7Ol1P0E3m5kTwsfFI4ZsuUe1Ys51nRtqSOUOe4XoShf3hcKnEGvCvmxPTPtld4dZ+dCX582ThABgzJSXKHbwPM+BSNwcJSR4D2RetYz3gzVHw3Gnoq81J5oh6yH/iQyOFGCYjXr0GVhW+hbgb75pYB9ZmWfV4gtvJQExHh1enckyUHOS69/IqJQ1NiN+08+pqtefw9MX7w+NQgjL10U88GaXt9MnPb/egRrEgcRQrLEilcvWS7OE68UJTEMpcIpChVSOotxXCsOB2KZL5NCLQfi55JUblO5FyvVnKCLFIo/K2fFOrrLXLhvRdtnhHvaPLHFwX6rv1fRwtnflgxFeIZA1ocvE7nmyrDetNsW6Q11Vuwtce6SzrFcFzHQiMCAeQQ1HRqbxxbBeFReyy1yFgQX87JfNKJh5tNecMbm3gy3JHJxiMpqZgG+zXUDrHCvxx7arlNOaIg8sdl74Wg2pQrQndh6CyjGsYtSOtfN2EIAig/cu1lRojY0hmIQbPrIgLKC3zQL7f0kEjfyfpwW1/FASKzRUBT/n59hXHe9dtpQxAkS34RpxjQ/4+OaVmHQfjtoVpMvKRhPpAnOauZYw/KOlVpvmQeL4xaqiRW/+B7H+JaBADbl1njIEIYCJB/NHuoaX4yqIOzOmipWYbp6sJYP8mh7TAiuwjL1XnoQ7zb7PYAJS9CZ2nB9c+y5YBOqTOIf6d23hAHXnfgbEpwvAvpTpGkLQMQiwcUDCTykxHfNnfMBagM/d6a6IIlFPMVsKyScshuM9+WxT1jLzoMwkroPaT/e4MWlcwNq2uPMm81Z3Pk4gc7HyPYnADlrgt5V/rYacvLZkUBaRxM12siAtUhj6HrIz/MGk9LfjiqHO9utE7Lt0KRw5YvOAbEeU8PpvmX+XRriuMoYuy+RPGlB8vcKX9qMI20ljxpbYoyhWZyRwksT4aF1epBEv1eC9kZmpywjNtfu5i35RHxG1zxQXIdm/YWmDVawOiB39+nNK3i1BYk15dP4o996yIs/CyAyqaEFMA+20Nebp6+t2OquOJcapsX2qOrLZv0MyD8Zo+fNpWM4xsI8POpP2lTvTWoBSeW7+qmfucWdyvlcSNaN/yWcRD0IGZccE6Xn5Sgm5fhYsjiiClSaziCWmivE6RQWxVG8/CTw1xUsgn7EShLHRdWrejvWUV7TLHylPRPZRL+L5RQI9hMZGVUCzPgxdJ8dM+usX41FGk4NRyy3NtytMh/uv300AC8YsDdoVhi+3KAoykKupyn2A4xz39tLWKscA4e1CyB5gCelIW6foZjMKecI63UZMwb0XsHuPiJZjWyE4it+ZjcVC2GOYCYbVW7jHWXUDKUbU6sk0lKinrGCaIr724sdigwOyesKnC4navqGVYFYOF3DFUHkAx4RykUntZquE/xUxw/KmOva7zGRtuPnfnycqAPh7sHeUMeki/sEAFY1YhhLvuvtudn1RMnzocF+tYJ2ZgbBodFly3Z/x/LNh4tX9GajcdEOCNINtWLSW86hS4HDMAoM6f9oOJsuQDyxCiSWpH1Lo7P9TJA1kmgpzZEu8axVA0AUGWezteIEyAJ8YoASEgCzLk3hL/MzgP3gez1Xvamg/jE6iJ2gYtOqqBLnNUCy5XYNAPpiz9/wLlQVl5qFSCCzrrt6I5qlpLkM6ZpT9Y0oQ4gq8DjXwGJpnY7W5uo5IWKKr+qgymRX9R7173zFe03vDFn/ErDKzS7XXIkaZLfKGwll+4yFQ1N7MUWPNbvCbvam6Q3l3zkz1ZPlKVHaFU4GCTQhXNbpLcEzOD7FrIlWsnW/ibuymjBpZQMfLBlB+6bDPTZajRQuF8rpbwmN3BZz/izGGc/ATybJQBgh6RLT2mcHhjcWuSzdOfbyyvQRpywOg4O0CAuxxrDLGEBe2xlp5ZEAilPrEyiGseCNG30LDeDgDnCI6tHyEsvAK2AmztaiYsY2ARNxF/ZrwXKqb5Ptn+eHVrpWK7rQSYJsZlyM4J9nN4xU5c7/MplTpZnwEkEeBLjM1vP5/SLg38Q9KiIwuyvt6w0SroHtBQNurKutVAfyFUdZ+5MWJ/XAB/0FldI2g4kgEvUtlUT38UQxeqtuQhrn41zFpPx1znLxD3N0q1lIFVGsny/yCEGc7ueHdXYHfqqMFCglpyIDAD9Dilusxvi5/ZNs7/UgfExHFoxrJyYw4vFEQFuw4PbdMzUZE1y6JOdrdypYwX9q7BWFoTVahVJz8Q4H7bIZWSKrXdDPw8qUm56IY43TrnwZu9VaKZjmLdxI3fd0ohqHcjbwUqj7D2D7rE3Ve2iO4iemkzNCIvNZ9EGUzOfBN6jJ0kRw9wpu9CrePp3zksZp5DbduuIdDeTz/wq5WcdtX4xUd9blFQjrOg4oRbEQqjHAw2dgUWRH2i4DAuiSeuhp34MGTKhMTXOKEHtEgr+CSrtBjoy+qBievsNLZiWmAeURa0k+tySt6wgMInWXbdn3EvTD8shHYQ62yf2/9ctnjsoT709uYtBrNb1AuQPgbe99Q+bk8B91a+KOKdVYCjvkmLc5+bGfcqel805b/PYKujrO5XrcwVw736basSqcsO/g8cn5SApK43J2xUmrQx2X6/cLnGaeGS0GCK2zWxaABVwCxClPYUlVfY2T3LwxsYRz2lropQ8C7N9HA9uVF0Rmn4Hn6tF1A0P0KE5kk1pzOQKBqy+ojgTi2Cw2YAUi8/kfgljhx32OX3lSzNTSpbCYz4W4wCWgu8WfYtfAnu7oGb7umcbygnBPgVxp+H5OsBEbbqn2FPu9bvycesEXL35FYcCukuhSZeLJKDT/huBjroy+cF6Pz+RO58uAIWnaPNXFXornyF/KtqsVBwDBbn8HGkHqZZdylQ3BKP2S61+UOICirXJ4Zqpvjnrqlr/A3vPiTRmN24KdmowKra6Ax+SQTrPcJ36dy7CBDvFf9oxaZougDZEAVRK+v1Xb7TmHmfQm1Y0fywZPQ8J1HEKb8HVVBzVxuye1wsE1+JLA8lPzD1635Ugddfd2SzEHf5k5UGHKbZb4eKve0NVAVmWnUGAs1FfTVo9iNdS39G1wCGRSwV7EcGPw2nbZNlkNmdsvXjT9KY3qy1IHub+BiG+26Hjw+N7k4ERFO8DdLxMt9lm2NzMI5HsTdbMsuml45DKZL905zPPXmVIdJQoT4G0mAfjp+hj80TjBiYUJhIhV35flYuk6OuqM1JNbeZvKzvIdkdPnQZbAQpoVJH6VFNupKlVgZAWi11Sdzmq/TPUWWVbT/aLMgGOFOJIr5IeMoEcgHgMrNqed/MAiM2dBS8AKfwnn3eGlEicyft1/BflOEdJ1BHzURbvfVeTkZMxfHyqmMOIj6pA1Po9/SvGKZyG2d/ldl7HQglNA6UwBt1qA4ej/GSfvaRu7E9X0YezwBH1yUNlGplZT3lFrrfal23tKNwCWRcqc4vKdBe3mm8xs56ch3mcVOZA+80fwhihfNW18bgtkzrgUzYHG4Ax9qnldkR55cRP3zJLSMwVtSNi9hqLizTggGEteLconrzfxN1BN5WGj5l7MQiTVMtTzbaXnBzXLSWDARt+J2tpEgxjMgIiureHtYsdV7hvl1jr6MoSnySiEcRRgxi+dLvmbNKWpJrrsgcvGjgKdOeZmE2Fov/EfnIeOM633fSQC2bKAze7LrfIz43q6a6ENTy4SOagjo1FNUdhri04mNXC0Mt4yQzz64sGdRqJ+zJu+EU/vjYYReZkKTr7l5jsfLGmT6UVlzJE44I3+fwiypW0n9nlHsMwQ32y4/fqMOVMH9kkLLePfHBPTqShgks49YKCVvFILZb9JDFXeYWN4H/Fe9KnfsmJVe6dLnGXoy5US3iXmO8Uy1eJ8KOoAPeDz4toS7vaJ6gZuhlDJJEz2gjAC0hbzc0p+2Um2jEM+knIRWZj+MVJZzGiq2lrH4UyHNhMhh7yxYTb/cyGtyUYA21MQt9Mh2Cp9UliyC2Q9fVKS8YfKaa41tw7YBWhHj5sLOIQvwM6vWmXweSP1Cp2z8oc71w811gpsf1BsJIzRyBGcfbehEY+LeMyaYK4zCjOPo0rKr3IcMy2hmetCHRsFQSnI67Gu++xYd1PbYNOHQ3QNidk+MLBPFw1SIm6Fp5v/8YDB0Jp0mTU3fY8wfOPfvFMcwKt6owAlaKheWClp7eYD1XcOpa2WlNvGEV/xqEs++6K8YXIgYyD0oB0QLDjQ3VFjXM+PTqCDV/vmjrfmklb81FO7SPJHtVwu+mkvCN/tWb9Ne/XuBIT7eHrOOn3s+PgUqVD4mydYos3p7Y+lRJP3urqLtyXCWQgtAIhd0mCvQs7ZxuL+W70QrzvYtiLYSxOBhUip6tVIbnhOkRVJbiFLU7RHI2A1LQDMHeFJWnbaq7OSfO6mDq0GdjggVTM3eoFF3k19G/YDDHqWsa2YnHg3Hubxh9F3KIIpSwBPjPu4ofGIS5LBK/2jBcNP7PwybRnqBYRoohqQP3LcRWNG5mFZXUJ466v3q9CsnyGFTCChJ/GgX0oJfm3TBS1VlxBSEILNnIvUP+NV3OfWE4FBNHlPmlKALiNZSFIVwDyLTyKcs65A5R8d+Cy/VCci3HGLsBwWJeY3Ji2MFEcMY7Ttg1su3D4AMHliN4/F292pv5iLHGD1WNaq3HDvcc0U6F5FHRhrE0odfH+YrOqXS5E1oZAMVd2rluDPHPDYr3D/Qg1cgDN1EAjoMgRghoHxi7MsFnyLTRjPB6MUFVsYbY2n+KKmpA0bCEnEjG0sx56sMtQOyke7F6TuusmGTZ9V1gs+WcyUJlTpgTnH9fKEfwzLBOUFSWtlOIeMvqVbH1041wOEXBo7QQ/1rUMmaG/Zh2/3uPb4OqAb1pJMYztmqlyjjjKvCDqwh/aV+5Gg05WBbMg7Gm2Enqny2GR98nRBn68y1jAOMR64nD1whuLRo+pVEuzMr4+mSKDc9Zr6zc7VXSkbXxRiq3yM8eZeaAlIxzrKjwkhYDcceBcwBmJUQen+XvVQgJ4IU7zkqI7YnD0LpY9QaYpt0tyaUoiS9dC4RVdhvsxrA37wDzpvt9pvAWMJcNhz91yjvoK/eyRbG2eJGAGqEm1wnwzJOS0/Ngjrx443G4gsTfssbzTK9NlbDc5EuJO6pko5G+l/lfNN7RNv2sMjatm4OvR9QOt+c5/M3pBMz/chDbUmZDoed7MaG+k1HHZHc5mrYsxLwlrknIm92PK1i9vnzH85RpBT4fV2bsqk3BBHyZakd4VsMN8jKd/WasDM/5RoW4tHbxIscDRnXx3JpZVSoXv1us8RxEnDv54TzYO3kGhQApjMwuX9suOfhYLBM9WhnQITRSgAUz8Yxhm4wAJ6Nd51SK8FiRizqJpWcaffHqxRNPra/cWzAh+NeKTK9yggH42JGsrcMNsbHVEViN6QFADg/vahrwmkSWXmCsJfxzBWZAqukqfaKT7nabELznuNdl4jTlF8HZzqiPQItnmT8pyR5X9fuCwiP6v/EGW/4HnlTRVqEISy9Dc/c5+frPQTcASIIBZM3DXQFwbVKG2hCxgtn8SJH/eMvgcL+4CqJRk2rsZUjMAYM2Y3lKdjYJGCEYnhAmcq2NcyzqWsNA1LeLSY4NtTX5GOF9RE/oOwqR7wYOef2GCaETIasEZL1+JwvfiHyUBSBSeaFxfSycoYTLIU4ZVWn4bD4U6rL1NzC/gXgEnGxa1H8n8Y6Wvlh7MjF37xSTc4sYLM65DIRP49AA1eUUHXkSMDm2A7c7N0QnzxKMv67nMV1OX6md7oT9vJ/LGQJMwzWWfGS1GaxGfCaC55M15KFFgiMpYD8a0F6co8Hw+gAMp25XY4UPnqEGkMwGH9nBPqOsgiAh9Y3NDtdOkZAU7oBLS630Aw/owCA7YgxcHa25Ugpb17bFXX/3nDtKa1xiuVix9wSOQqwCtnuF52vlGh53TDCC2nrDMipPnJfZR7JtowXfOeAQsyePSMYwMZG+wF1YkrqWdbuwoIJhYsYYvATiXW7vKAoD47iJoSHC1HG5Rkq0scnaX/0wmcvlnod5dedrqHb0OtXWcZKWkZFjKf3ahywx2yHpAM5/pltA5048lSDwBp9qOfwJ/zBmOx+DKxz0rbawWmdFlYoyZHlqxAL/KKsEnakXL8oGHtJuE2Ftc6DAK6XSWQnVfqAq9BdlFqFHZ0pUyNGTiV4tEMRGpgb5sUFr3CqGdnRK4gXlloAhTf8AzweaqAOs5K8O8OStOHK8jlNnmb1keFSltJNN4v3PcXU9iKvrW9JWrA0hb+XKcN0KNZCFCuO0FA6mwsEQ63Sd16sHjQTdX5WsHrbSAquQbQr3VqGVo0mq8CoDjwGmK7B299hLdWdXk67AK0NueSIns5pDhcv2BaZ97C5uC9DTSCPuSXMxusyPM2rNk6lsHpBUfQ2aS6wY701FrklYsvFzhJVUNjpTxp3DDy4sKTwuAj99WXPy1Bm8ZzHzWvNZ6/K0uLceTqfY2ETnc4bwN5dBY6Q0leQK+OIUs6KpLQW2eSCazUyKSgVfV0zAusMskG3r/Df+jUj7A8BMiolMY38K45OSyFr1TmPWymwZlxXirmGWVcZVsobQdeOK5JfDW4gsBIMaroWDIuhkxiVztMPWgJYcu7qptxDHVf9hwUMhyhO6IEeL/jZKcLw8/36dkXGvcxvLHEAFZbddtedrGgzAwyywwDYkrQQaPMwkKzJkEZF/6L1rpg9SfwMNP4BPCJ2lhV0K3f2DqIOI54mKq5qIsVFTi1TSPuwdMOS5HXq/zR+bEDmr/yi50bg6aEInSA7w2w14ncMYWWgWdCnr3ruGVvdiL7RzTGOyo9EiXyzWTuDDsIZUYafH+mWJ11juOzPMu/4DE7ggKzGncE7yEzhFMYeKbSx0cSNUIHY7OZ/8mLa/O1sikRwdQQdipzm4yqm4IM+62GX6luk+1+RbuWEv+S17L7jZSihVGQvnPeEgBerk4z7hsPfTsQ2kg3P+siq3dQiGVn6x5LMRh0hEtamWadTKp96rAbwWJzhZb9oJAVCOEA7Gz8cv08JDdSMSRrMcHcP7sr2XP7sZt/s9wV5QBRCBW5uIEMZISlHa4rinu/t/MTxWVsXuaUGt3pLM9zDo6WgWLEncKF8i9mc4ajgZVO6jhhLs+9NKCyUvo70aIgu1OHrUP0ZSENh2VknFwHTfMh514St/f1lcE5241K4f/3s+MQAnJQ6K6pev5RzvINjTlRzWJardgaIWWMF41H54GdgZxljAOXdVKtTldV7v2qhiI1zon55V9C0bMDmQos/7UohuM2QIPGmEOKHrwvruxQOTkzvlOvTUF6AUVDgQ9XI4bYH/Ko8eGCrwDjozZHUfmJzk/ssSRsQBGW+r/wQ4oAnmYhBk4A5JPsD/V5d1fO7bYjGj86jkIC4wDoo8Ix8/LN3sqp1lOhc3PmK7gLh6Ckr7CLl7zAXqrqfKNLOmm0MMg5nD4xxx+IzngoR4hhSRMwQ4ulDMScdNPS98GuGjVp/MbuMSOMFbDILf0z3dWKmZTWMywwq3VdRdycb2Tj/mnTjUUmNYCEf+a5s0+yw56g435oiMDgZgMGf64Ua0/Q80tOPUAJIge6gthuuQoC2+RjgbXCI0aTa/3zANy5dtNG4pWM1+Od4pcGdOvpIUVdlzGMTHFreMnUWiwQpst0HXKOSMCP4ild92hv4/r16OGGOysfW7gOK1pU3n5B9Ns1/KkbC7xCHSC3/flny2ffRU8PkKexD4Cb7Zp2A0n1Zal4XDMdm4f1OvDesPPSvfsQviRES5gVyUaiUwgMeS5VX5dDPOJhoCuW0U9fbei4K+fHRp0mg0F6J1oWyZmuKicqKZ1t2VEc0Cl8XJedRvwrOQUkyeY+u+15jjzIRBdxrj33xhIfgwjU/pRePvUeb5pPOGZuqxDJxuS1N75zbNrqr/aU+NeNVNQNCdeqERW607+9xqZH2puknXgwq6mTPrhi0R2cSTrNf98sll/16m4aQIR32CDAn08eIE2TmAlsSH5aMtE3ADLCxbYhLuRjEnOuvyrtelcxFFR7H4YGa41dD+I2kMt/Xn1oloZ8i/MYF+jYsCVTioKntsXuHkXyM8k3ZekrLY6UfKDZRd/C5zlJis3DIZeoOqipq4r8pMwTXC/y9GqbKJk9ykMzm7mACOHG5qX5K17O2DQDei0c/+dbQCKNuWntAEvQoz1a7W4MkGVuWCa1ukWaiE/iH7pwvxAYLLUIA9GBLh3JoD3FQNj7rV8yNIOAm6JiJX4YhUBYGilirs1b4sFs8p/bDSGfcAqCX32BfE8T1rZgFuPhGhEuPUsztQY8AHHnYAJvEcJ31crxfRDS5aDVrPCkqRRrsIq0UZ6ykiWe2inzD8LFfTXDORGz+392hP2XETdj0O8Ft4G1chWinGYWJ1t95B/cn/bhgf03/wjVzm8eUTRqvzCJcxuUOCg+wFtUP6zdQoCUL2NzMLaLA1ktwIoM/fTYF9gz4W4xJFX+bh/2YOlZ8DSyl0UWDoPSRJcGvnk622xUA4BrI+hfw8CKc3SXweBXNEWAXmPpjii/tdfRPu1TR7kCxxD/ikvMBHPtKz74l+lXC0rjzvF/0I+7MhD+t6qXhSTVguLf9bThoVF8ZznRctWDoIShBtiP9AMuahX+AVxOSxADDWlbELZq6//w2ZnluJ9mmYtcDX9j+GgUdLyEDHwosId+XeWOWMXuAcjpadPcLDZxA0zdPR/TCWRaAfNS7P/vRBkyhi8m4GpiSwXu1p/ZZgaeyIv7iEHrS9rrVAywjb5nZ8kBKIQLU32f8ybKH2AYOq3N9t4ou2AQBCGLNIz4W5cRb2Dz83PZtOF3V8EVFFkTOa1sI2sKRpWRmFs5zqXjeBlrt+HHdkQse2iPh0krQqzEq2EVUttizWW1nsYsTmpULYJfvWC+FXik+Xk1VnkldDZjhKTQom79xDI+wIfFi2yS/mnXIs40FhpNwfhMnebhawlMv4k39AP2lv25SDjJo4a7Brjhd60DhQYbpiaSidgTLdpV6fbsmW8Wwg5WTPXAJaR/0ssMEO0miNqvFT7z+S/in8sPmvP5r47vOO1uxQ0GHVkJPry+tiK5PRhZNWfcrG+y7tZSVQDOW8OBMRshfeRA2CO+OVvKr4dfgvDz7MwzBdyXLkvSRifS8p7wNQzt/GpHioOEERJCwl7daM1wR7cnqlMmAmgTgogqIUA/lF6H9oyF86LunKmE1iJLkGHHTGZ+wONa7MKEdIDBsxtckJDdYHq0MgBrvEBQUGy1o8pDmenis8Mism31avsWctEA/KRbeyTzS+DFND9yiyhNz7TC/pca9ApciWH5nhO0BIfqXsDc3myf4GB/FmJZ+/B5dFWTAep1fT4p4PR0hiDqzsYC5uwDEKViYCYCQ/gBnu3jtzzZoocYZP5vM8P+/SFDvQ0mYUJmYMx7LYnHR6mZlySBRYYovFjvf8n1DbjE0mb6OE/t429UEa3K+iEqzwNEtHHH25s9zSiG+HnOVzZ+TxT4tUllEYUg21nxsx6cn9Kt90O5EsjwY5oPPq81qTQr5RoaKeOH8kWDMl+OP5k2mUMQHc2tKYTQC5q2fDeOhCPxEw7B2v8qDe2pMspxj5wwwP9CHtDtAgO0XJP5urVhOOB52Rx/dH6Dj9nFGdd3BZaJiT+Tx2p7iS734yM0lszGVCAm4lHtKaPpJYirhchbrfYs2YMlsZqx3OPRDvh4CbFCoGy3xBDhFD8wdJbJB0eXw1gmP4rn4/t41L0g0vPmim4T6eDnRyEiSOP9DOidlCt6mjaly/nd/omrZ3QJL4nnl9XPuV9W+f76l5ucqqcqn78SBvSRhvLjynrSubv2TkEdvggNZHxWL3Pn9XcaqDOAtQSXVgtUDpDmeMTI8ODDLU3fS8kJlC1dAmQUeYBaqfS3tCZ/CDvnuq1xw5hy/SKt/aZ+7u49Pp1pUxC0V2nLZatFJopfOAquVnzjMeRVU/GmhAfupkoqd/1mRgAtZff4Z4cc6tWc7CpFwKHqow2vX8IV0t8/7LzkP/HaPyR9EG3f054jvYKwpag3Ls8uOc6vJaJqwzNIb9lOsOIWeswiRH2ZcPLgehTnM69dLdNMU9oC4ZdQ1MohVpgrfjHMlJmd7zCIW4kRnIUFrX6TOoRp5/kvWkVW+fECQrFkDCOS+3KV3J2Ng5eWA5BbtO0588Hd3rB1KpGakkJ069ip0i1DDaMss/3yDtq9dyys21X4bNVQBpS2Vbr918sCQcY+accuzdF0HXmsAHr78LlDPzJ6d+pwD4KnxnVPk/2OSILuENEp/niKx/OCyLK+Dpt6kl6On7txfOvnAswn1/QKBYG0VyZaYpEh5eRBWP7LlTEiNXNGcpj7DNzHiZZXQ5i8XdPOSVFpSDnmpfI1XzVbOBID0exaKcE2L/DOSsp/wNy9wK/egpYkLwpb6wlOUgjVlFqICAg+y+c2xg2flc0xnx0F/wQ4tgvKsVMjZIbOjosw6ldGX/GtJvfhvHKYs/KH6Dn/C1dH0zcuNhWm0qIdDdSnIiGAv0reNNM4DqCfBgrSaYr/AmIGfj9vhF9C8YzOw8l3OY6DnVeWFTif/ZAAEAGgBAAAE5AEAADwEIOQIAAAAAAR8BskAAAgAJAgEBCgIAAwAZVGhpcyBpcyBvZiBGaW5nZXIgKDgp</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left IndexFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>60</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left LittleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>68</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right IndexFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>72</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right RingFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right MiddleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>78</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right LittleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>47</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left Thumb</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>79</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right Thumb</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>69</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>9</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Iris</Type>
            <Subtype>Right</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>100</Score>
            </Quality>
        </BDBInfo>
		<BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>9</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Iris</Type>
            <Subtype>Left</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>100</Score>
            </Quality>
        </BDBInfo>
		<BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>8</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Face</Type>
            <Subtype></Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>0</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
</BIR>
 #BioValueWithoutFaceBDB -BioValueWithoutFace=<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<BIR xmlns="http://standards.iso.org/iso-iec/19785/-3/ed-2/">
    <BIRInfo>
        <Integrity>false</Integrity>
    </BIRInfo>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.670Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left RingFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left MiddleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left IndexFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>60</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left LittleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>68</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right IndexFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>72</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right RingFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>RklSADAyMAAAAYjeAAEBAQABiM4H5gwcDCArA7cAAAAAAAEjAEAADwIAQAIAQAIEAAEB9AH0AfQB9AgFHQERAfgAAYhdAAAADGpQICANCocKAAAAFGZ0eXBqcDIgAAAAAGpwMiAAAABHanAyaAAAABZpaGRyAAAB+AAAAREAAQcHAAAAAAAPY29scgEAAAAAABEAAAAacmVzIAAAABJyZXNjmcoAAZnKAAEAAAAAAABqcDJj/0//UQApAAAAAAERAAAB+AAAAAAAAAAAAAABEQAAAfgAAAAAAAAAAAABBwEB/2QAIwABQ3JlYXRvcjogSmFzUGVyIFZlcnNpb24gMS45MDAuMf9kABAAAUVuY0lEOkdSQlQwMf9SAAwAAgAJAAUEBAAB/1wAE0BASEhQSEhQSEhQSEhQSEhQ/5AACgAAAAGHZQAB/5PfEyAULPcMBeUfFMhqmNzTsZwsCuZh5SwlCuOLivSw/0GGdfTY66SRpwBLwzhqjAvZlm5CINaAedkP8r3w+skJs074FoCA8UAREhmln+taOFBL22GCiaEoIVhpBoDxUCeph7uOK1pWnt+gX9UWe4g43qdpfYD8CQBENNbA56GJ29QaEU3c8TSoQwzyxC9xeRKUYHdebQY7KrrpXDHHV4kAJBrq0r2b8JAIWZ7/D7ULtliGSBAeseyCki9zuOhWgFEFe7zGn3wGyNQjejZEHl7P/XIjv1t72+cHN6tARspUslzxrbM0iXZULNaqQLPY8Xm6ivmW2aYn6uEsdEUfd2sTcjoQ1kVstKRnD4TiOK8JgD8D9nnxbvpUMZY4KTSG6VEh0faz25ZWSMLGOW5qI9B/necseAGoo2EZu9Kl2JG4X80AUx5yexdVtdxlQB9Zh8iPDrCrXcyYJG+5jPK/VjD6OKdBg7MY1OqA/GcfGe/MTF1rI7mBIIaUf6hXv0KA8Z+qxQF3/j/IFxDXKI8DYQXPHDTvvPKtTPHiu4hsA+iQmrRG8Y//GgJ/vdXHhnmpwxw0dvJfWg2wHUVVc2S4b2Nel3566xiDPTnr2mPl5Hl8JfFRenx9KubgeegyVlZhteFaLix8j7uZ2szThbydIfUgKyyx7TBLErQcPJBWOL14sT2knrmtncH0ru977N1Cen+RmCLiTEf2KhA0fPLENB84o9l/1mZuY+RdwLiIS9HHVrOmaLx20xsGExAeCs5J1wu2ji2QqPy6MGR9nbfuuE4ktoCWxNcdbFZXtSH2bszhglAsrpmOTcUlGYWg6M4k2UwrjmwXuRXNQj4SbWtGvCCpgMd2DlD44COZk07MQOvpJU6VtaRAgvGmz1UUzK1TUyEEtENL3L0sDxf8rcXpciqW/1jJnASfWdvn69pFMJksfho8Vsij8d1FbsrkhfS7xkUHwJvWD0D1mynXHFFIROdxNFmBex2pzvE+U/0YIf9luiFCoU0WihCVKWYPZLjrtqh61JEvd9G3U17PQvRY/zv9ssBp/2J4UI1i9AsOV/OsEW2UY2RznBYhkSrvDgqXIWxPTo6/F90AQY3lkwKT6eEvlL7QNEOPoSuS4H9mmH1cvHSh9y6ghj7R5JGJrqu/BDa514DXE3rgM0jivNY4Qs1K97K1iVYj5HFWASFb7K4T6uTRXG8NjcRnjDYQWGuVCfz6H+pQDEQNldMsPCi+i+IXBxXpTFB8792uI+3etWaPbg3OPHKepZ256VH2qfxXcY0Mrq7FVH/L7WxYsyoHv6DJBrCC6zoLqvxQBrR/pLhS2fqHypdvLyhHnD78IsjrayZLyv9UpuJOc93u0MndN3A9IO6ezfwSTe8r1xVx8nLEIrhEofCxsoTduxC8u5GxL68oB/oMs3e32wWKM6CPmtfgCAtmVxdUoB/75aL0pZ5dRg+xlDDCiQBSkqDoNSgA19+n/KmzL+QXn0WrF+TAKIk/aTn7hLyl2sbAIF6J1+wbo0zfJ8/8ySfMlPzpoNfDKUAXhK7HkF4TFRmxlAd0F8ktNnmUj0jImka+yBON5rEhPQ2d8La/Po1GHUBd75iHfCA94Q5vB+jWES/HAH49gksUYz35PTqQTxPQHrIUgheZn7dve4yE2XR18rT8fEZgcpx59bsbVDXpRSJIAFL726LQ2yCVPrDWKDAKvfr1xV2GbX3IGtft2wNy3joIwP8bfXghnrWyo1eI0SxQC3aVjAP4l7tN46X4Emhwv68Y5m4iUzakeqPC+P8ZdW4SJB0bqDyD3NqosC+fY9IBycXPRKHrI2Ny1fRhcOwFuYsL/uTglK+TSMaoDfBtYGIJtb1rCl/6l1TQ9nEhGZpC/JNSIwiOMZKWvp9/AGY6ozNHZ5WJYCRmTv1xLIY6AEzb4zFo2B8HEfew4aI94GSOf5hZZhkUirJIL2gisAB2b29dVxhPA0qLu46SVqURNOhmFI2vo3gmPYTFSmHcSRwXuYyu5wAi3d7nKZ6cQT646HIJkPI3OsZDfad7ZAKd72gstMUqEF89cF3CBw1/Th0lhTtFqtnzxYsFjZB7JOkRnBMe1MQD0T51sdH8HR1V1mTnUTqz9XhiQWB3wLmZw9QAe9XemCEJYg0b84Np94lyGDC0IG7OqUGtalxMG/mxXvjn6hUTrV5oXgovOk9FTkKDdEOfyGzbutw05TARUJngnNcXd6P6Eg4pw6Cl43b+3LhZKZxRfz6CgkJpaBV+JWAM0/XvCg0stO4R+fbot4e//CFSZ5QLWUPVGj9a3vcmRBMKrxDvpqQdf5+O7tSm7H89y9kGzwnS0qUd6h3S3xbd22rJFYzMKT2BeBApZl+PGwqqUS7MvVM0hGplwjObKhxfyxChckpejwyLjy5s/GLbTtbCF2qvmOeTYqtlbgiYZYnFshYloi2QlwaY7eiWN4qS1yeSvJUeuh070n5AYmGeaTm8mDCx5OiKwPrC0L7jDqSzPzRyucKT7r2S44U6WulGgZQv8oDD9cNQV024iDwdIRtzuRVe5GkHgE4dQuLUzyZUxzHFItsA8kXlFUM2MDHca4HzCrqWphz7SayLTzRN7/gaBuzjJ4RhLG1/kcT9MmcILCmBeFMxKLzNjL8eA6D/cm7WFJVi+UyfZjU1y3YUqxT1K/ePU+E1LVVlu7Vp3elDUebjb9L8WH2WBMAISBODL9uTedEYYsTeX0ebE/vBIRQt78vXwJRgReo+Tc9zbF3/doxUvUJI5pOovZnV6nFt9pXxKkflDZwFIIeI9APBr6Q5sd/tIApXuqtiCWU5fWuKEv4NKjnFtRgo9jALP4pGF3QI+UuuNA4EIhC2FIeux9+64gM6peogUN92l9GAA+Qzuj6LNy2hcvkfI1LkYNNNLhWTKMqMOjDCHGD0bSrpOIo8UxMdc7owiwbA4mQt3CmK/1wW/uAbDo+ZLRHIbjKXRi8lB+Sxm1Cmy3kIq/RRwZbHiVd736jWev7LOeRhcg8t2adkslgQjxasxo/V5ChkhsUrIo/oqPHbcyN6DofVYH66iWttUgQu8SV/idK9GzUx7Yt2NNHz2sYl451r5YS6JzFsNqGrgniK8SUbeSphoWxRBT2bWkeH6ZgjJPIgqdqFqIZInS+csNiGWWTHWa0XBJ7qm/ETQ8SilVtWx15aKLX6O3UYCUw84Cb7KIKb/PI8qiISGc2E1eDZFgi5VXeRLquDDHI3ejBZvkDhCduIXhZK69rHLi05exWdHpF0rG3c+6iI08okndciO8GJtYDYYnDYiZGn0C9J9kKaW5lWALH0M03fEs4MYn/UfYeMATkJEdJhVodZcGIFdEHRJSNnjO8T/rWND8qTPqiAbzBtzGfcDwqGxPy8g+rUi33OXcVPsut66DVZTG3edTf0SJ+vauDZU702r9p5pgfk7pV0VyWdRVHXtWvXaIdvb0WSYw1fKIVOyJ3qcQlU1z2KwlDCBguCNXtD1lOCHhEZ8zXBS0/A3OS9yVrgqtETyANa3szY/vczXpOWhZSj8yIMLlOaG48yw2WCRVGWsxXa2pb+8AvGp0Vb7FBSyQjwfQ7HrgNGous6XnAebfqZdwrpRvn3b/abNmv/ZCM2uCfXrzlLQZXCsZ3syjuWJIPyCxPbfky6xBb5Vhae3Hi1p5/mW44iPvlH32/L1bofMCUd6QBcvVyZavkYDRWwTKnWhRylqM2ojuKJuNuwR9UlXdewJHznnhGocmmyB48dLCtZoB8Wxl+CWpV2b/lc1B44rseygs2zrrUAVxR9k2/7dz1SEHbkv4JQo4up2Rs6yuwzCzap56GVFBdUvTNLKC6yGHAXgWooL/oGZ9xboQ2CXaliGh4v+GzCku9EO1V2zkRLOXvkyD5L5HHcVn3sBHTtD7FwR0kmw3vVSUTAZWqk9Vw8XPSxYM97X9K0M6XAIIkfOaw6oms5zWlgaL9tAt8joBSGpQ1gsXjyaiOv2vaIvn7Qmqrj4IFnFIif9DqQve6vG8saudMQg2brHIUgIhWiNYHykVBKnxtOILzRJ7fO2b68q1+ABjZxjZUuMPmX/pTYkmu6g7MHbIgbEFM7sX0wldmebiR1eiDun83mDcCv697M9GpP9HzFUoGjjD6TIaJ0dStrf95iTVc5Yk8dmKoQ1IOnB5yq1MYpiVf03cogyjkJPxV26X8rbZZeU/zZmaTc94l0Uj4uGut6IS42dw0Rm0J/nWg4hZ8ULUYwE6D5HOXHGmAdYV60AjGvR4FsL/dlrH6mhrdTOAa3GhblqHWdiqxlW5FjHen78Fk2oN7KFCFOcuc6/nAY37yQT+6P7qHk3hnMOiQNzcsAStej/pFSqWzd1SbOI4h5Z9yc4a8L+OoFojmAzbLOUokEUI1BjwQUlBnoGopAO/ajW2+3tFhPE0ndlH2Vb5IPCsiyVuN25hknD3ZWshAlq2FPMocb1JE7baeLGt+UmL0GyEWcggOjOrZUzz6vypMBwaAsCjU1ve55/nShExmvQYnUkporlAtYb1HVjCw6MtHHdwktrwUsge51vDDi06lKQdH0VxmWZr5JKifIIDPBIr7L/GuHg40Zc0pjlXEJczXP66zhuLJfAxjsOCEaa4QtffWajItbLW0iLD18a8QD1dGvcrNT9rOUGw5jdFm8/usbwm7+NyHXD90veUYUcSUOpv2UYtpsE7JR02obj86MhFwIo/vhh3241E+UtqJclgwa9IpDqbe2WAK13kiuGAgP39fHs0Xgt3g2p41tdPirpyrkJybBOQLVs3+EHLf7TI4JxKSOPRYfyckrWyCfm/bpDFzlS7a8XAc0wz9ZjX45N7ySEgIWKRBXAq01e/YGt0/9YorLeezjJBtSCpkwlj9eBG3nfw7oB17tOPQiiHKhLR1/4RegE6IukE2BSzV7pL71ToWbjM/OxmgOuWrV7703pM8T3b6DYCqkwERm1qil3TlCcPcLXRyO5j/y6i/sT69DGu3v3QrzDxX4CwG6O3h62613II5CxSnzaP8qBfLp4Hphx2L5Cn+n+7Sx0U//buFHxAIBA5BPRDemWrzwIgc2PJ4/RY9P/32svxkBo1xESFKYbWqdG1qsq2IXUdP3NpMAzuo3tefgpEo/aWixr/bzNNGtRPH7my2le15jRKL1+Do0UsPLH5edgMW05BN8zMas3yoTi0NVozW17Y+BTdE0/UdEDd2/3NycwgMl3+07Xbu1sR8VmKRjqjG1Ll74KQoGUYPkFoCkVH9ZL1eVvev8oZt/2FzyvZ8Qf9oxnDKsC/IXmzPSKIrq78xg1lW/PXOSb0w8dG+NkeAqyuMgD+9FR/NSdOUSxPKUPmKgUOUykNB6MyITT2xuW8ECdo4Zc2V74Xbdp1lde1bjGzYkHbagYqMJBbvPg8aslugd8FsqnUxq7ox3F+IQqv5VJRNz6EPjKTHAIasMXfszSjrK19qlFrsihQQAIzo2OKJugHQM3vz9NYgIuaMxVMlSZGLapi9c9/KKnrX9CXH0JxfWW2BRtGGrwlHGSwodyo/Nc30ACtUt/NcjCH18BDJ5y+BNgMtdDfxhbQvpPly/Mmm6DMfvtex0rJ2idyZ3cYG/X0msiKfYXZ9oD6WpA9/fetp70bL7+XkQUUAtAb3G2QEyg55oSiEXuWlZsTtAy/7XQ2FCrDL8SZ50l/yZLZR2C0aLTrMFf1INigSlO/FEY+SpZbCw7xCB0GMlATaB9tevhJKxQY77yTcmntUOuxYVG8POn1qx2Xpqf/R6+Q4Bw518jqeTLdY3ioWNdtu19RmnfDg8xY2X8Y9w0tB2CBViX0ofRmycmyCVdRqxDCO259aaAPF0TLi5/wPbWc1vlroxYdTuEkHoXTA0UgK7/pLVO/6lPc2tliNzpKu1cg3e1w2BBUy8M7cUI53EvpuDtDtSwJUXZi5rkJsbi9q6lxEjJ7UIsPq5eYM+5rBSeN3x3Ub9D1df57kqtHWZkYMyeZw9CHgLU+yYxDsModCK8mj7QuKYmKHP56B0A6r71diykr+oH+qf8nxSQqX4FS+5vB2oGNzWCaf8RVFMrwy9R2180u4jPrjIWHDuhC8rfYedmg73rWp89r4TGhyU/3COQHUjgmtc/3QIVIS+vsCqfSg6XBK8IABzUPo9Ey8GW5kypp7x6txu0wK7Muph1iKWsxbcSdUd64LOu4g8L5quGYOAOx1emXeDpLL3OIbvyZea0HmNb4K/euKDS3s85DBrypNw3KifEbtMmMHyBTaSDej4j4LXSLQTmJgkCq0/HS0xqK0bect6hksB3/WcTo8Y2x/rjkHA6ux2941Lpi2tbqvPtL2anTcL2sfO/SD9gE266gLrj0eNjqg1Vvx49FUtpQszmFnQmWNSK2UjWgraN62+Q4XCl2jZu48Qt9VvZ7TCS+F3dSpEAzGguUVDl8OHMNcnrG9prTgVb1dJd8zbiWfYmtGi0xobafgUUVoVRpot7TEwnjnQ7wF4hs/mi90ZVKkZslm2Oo2zSShhZpd177YltbP+BvCDYvajLmbWXyRxPhPCB/yXl2Ibrx++zIe2L4l599+Eraur5mrAHe3TXV3cPbrF1fuTIDHw4ozVNGOQKro5IFSNVi/GBxrX6ia8A5zn22dUMP6Iacy8do9+UBrJ134h+Kve0awcrtMUYYdmDNDc+pJoy0R6MLNr5U2XKi4tmHSyldXmqJJkmqvYrgKjPI/UmzwPtG/upAhrpIPXsD6f5GZ5pvIvEIBZrTY25MqiZ8ee4KSZ8CWiWt402ocviQsrZ0XNQe90AB3aMtLfgM8sJ96b9ZdDCkmwA+V1tT8aQ1XZAaUQmQl8825V2jML0AfRVCcMvRLVi+lu210wipCeKqBChJPaUiKlYxKR7+WMdjHzuxchTKhejq7ok154sbe3mrTk+xADcshL6I6qytWjaRtwdihnOKzmTVzzuI5HmzctuDiV+oBJkmFe0KPUkfAuV9YATwC+tlqMAcbu8+qdTsxzXN++bXo4v9ZGYCaPyG86m5KzdzM1ttHqLT97yoLbpHeQ7ykv7eeZDhhVHbHgjchLKO9zn7yNkQiOvFu9wSIh4MT5ENkSEceL4pBO9lg+8gFt4VuJY8wAwuJHWRk5JzClSPZlWO9AZ4guV3Jm5fIvakSvHTWxetkVnWKJmOOoya6iUuX5xmaahVBRLD5Gz9ydahahjwlmRgJyu9tJegVPqom8QYAth2K+d4SHwMknn+o6V9x8VnQC2OPz7F9DD4zJ2dMB5Ty7pESD035QWO6vYNi3Knuz+8T0o4rJP1IjFflanq1ScGaXDkF4JN4Dl/7gRbemhDiCJv81CCK5aHoFQf68oiDfajIoCtuoDaSHn/nGRU13oW4Mqd9/jbu9XI8BhbbstNfOXbBlsoDcJcFe1O04RfvPxuffZLgRLdONMMcfQvGnAn2F36F6nHJb95utgcgE+sh9MTBgEHod4dIPwVVt9jTx/q2iNYWr6jF5iJaiatrYoQrrcrnur82zHj9QJfu/EoNw1gjEcewWcINIqJjg9bytMd/pVxG5Cn2rRRrDTtBI0SXzaAmDeLG2VuDTsz186WbHdUGlW4ofyA+nE06ilCeXLRGnYkhTG9JKr6OgP/bapYcmjYgOaEfrFHrQb1NFU+9AvFSNywSICoW4GC+mLv5QN1lP428N5Y5mQJQqaiJ7Re6I8OSMVSo71A1Uxjj+ov8ggUmKdP6vEx3dFMMuYypxW1AYBz5HeHwhNiQf0ttIHKKfNJLirCxvDjw3DZtFMniYRzOJ95L81hAsEZDGMgTYCWtytJgrLdrHgBscz/CCfVMzxoUSQvzDPoM4H5SueRV0hPb8ee8o2hn04UPKLONsJGtJGMmcrWOEvdO0mAQUDGHbCgueYMqPXqH7nbDP7sxh0w+SEvEUMOG505FK7KReR5hehOAHAlRpmGvUwS2Pi8OmriCH7xIM3d2409GFzlXFkih0w3djQmPOEfkrxj0I0VsegvnYXzOlsm4PrrymxIBYIaomR95/iDfPXkt5xqxqNy6R/WUE1JWcH7mN9bvWzdyjx8/P86lnB3nndDYchiYT/pZhZBbQ/YKM35OU3RGI5QC6f50Vd0UNI0rn93FHIE4NuNEcy7lVsqY9vY9Y7rh0a9vNf3FhSiYiFCFZ2UjVQTdWurDfJL0/Z1R1olBWqRD9MHdByUwcXO3tu1HCpYMWBgxSkfEs4ZMRJh9OyMyWBTtVTyXhDinojYNgzzSslABHPZbHCBDpEEiln0roxJiGQ95ZazZwjSAdGU/yRAMdu/s/gYHYFqWDndDKR+QEahaCQTohKu53V7Hp2kfvHRSsPjnPNAAZTDYYNJtHIpMiEjZ5h7xa/Fo/Z6ucgJuNsKRtD0QpPDNZlcr/Xndc/gmjpSwV/MGj8VBEMZXoCKJYgL41wbF3aJ7EG+hfPj0iIryzRd1eV8Q2k2lTVyF0chFZEwbzmXsm0ubZ/QF9+SRJfY1BktrTF+9yvkfKzDHOopSl4VU3fVo6lmVnusPtdrFcg7sVkxHyc/SsLo2qPIBfnGZzgXs/I4pWF+ieMZaHUHEeBpwlbdIuqz+4qCYMZGcw8qVytEo1fOTPgXVzW54rhygyEYvYhLmYHSYq6/PDXidkCC/SDtBluoc4utHtGv1JaZbxcU9Jz6R1E+G87RsaMFkxXIPX7/MBm1tamtsaqTos2pL9kmOjHAuw/JH/QjsJfFdVX2gbuvXWdlFVrTiPk0JEeAkGbyGNmX2nX2n+gFooXa/aaVsSBlf/JZfZmuuOzdkllAH5ib++5w2Zt4qSVDs/ydhkYU8EfTixhSjhRrUXcpptmTN0PdmbfA18Dmuq0dKiwzs8Lmp/y6Xcbrrje68xqrlPnE2ZEnc2wlE/LQA+sQ0p9UexP7ikIAtJkXDrrN17vycnt+dARcNwUd/zqSUvmZjg00KB434BBKRx5Q6jzSNphlockjwl2rP3BbXQelQricPZNwwyfz9/WH7S9w01BYHrI7bmz3UOPecYJrytSOdvE2cbZ8i2vV4Nb23Og4yVLLc8TuFIxZxby1jF+a56rsuZHFQqPk5Jl6mirYu9eS7awIk+wLnwan+ib5w1sPQZ/qPHWRvMznM0Puhkvn+yZYn2swYiRQ0bLqKTRPYDeUw1224O8X70BGNBLThq7N7N96qZuIpSkauR2SFbO6+Dgkw7haer6Aowo7abAC1IfyHAgXM0RmuoPDL9KD+JVZoM/mD2BvtJZmzQ28b4y8fz7XWfkEvLkh1orB1S4ed8exiV1Ozq+sRIqHBFiw0Gjgkbi5t9F7wpDffxUeGDkuVuZipWLhzgp5/Orz9B6jJarbAMlkIYfwnYggYwNJWi23hXRyg6eEK5V8jdQHGeshNSFH5k2LCQeCjpFndAg8aPpvEJime04tHIHjgBiYHNxOeqPFS/X1KJrj974ihG3mDsEwF+UnqJtqlM+KLqun6ZnecSa1xByuBGFPNRYELxivToo7DVF8q0SbqT1yEhXLwRj/6n59b9wAb2sXHxehlGM7VMPeHfpfUR8/ScIJMt8+z6dOZ0ZjkN9oX7G7jcghiDWo/xb0ycYRqM933ApXaUdmLPqb3yDAnKE0+PFx2N2hbOJM3MsHYEydPEWgkc/1yd+t4vcAnS682erHwf6EA/xe/ImJdSRV6ZeSQ+DhzkbD9DuO4+EZ40r+TKdqeuTs0CawP76hrl0bai9nnVqk7QOYfbwcTeTr/Yu0V6kBE3lHrFs4+fFxm+OeE5Dmm+SqpHtUqdA2SxHn9XYPIKhMam4/mYpb2suTLuoMkFqpJotxN6e0NqbT24fJFuKyUiRE4yas0zIpUkPkMQEimXYxTHP+YaLFpj7obvLZLVpT6QZcSlRH24KCQH7cwOqe5IPBkksf8P/TKv42foX1/MpstIFc0b92JNg+O5Vwe0tBPiwF0WHpyg0vMGZuir0orEwoUGQi1hnOSymbmagXCJ9N2PtP60Yglms+faNFXZryd0gVD9MyKeJICz0zMv5FhaQr2N7spStd4rKQwpGlp+d/31OW+1wsoxzdFG2Qp+s98yTm1ye9fKlcvepZ5Sh9fGRlKcUjgpcECfVsNlMe2ARfFSBPUh8JFyslIRavngZkqdWauHtg8vHpWrm03J0XqXYyLw143Fbdp7MHCfIA9Hc+QMuIvZxTT6akYnpEBRxfHtvEevdeB8BWI/zY+FvL4QJqF60HUn9fLWA+aom7GRhTtyTprwP8sLA56xvKritFj7TaYiH+szUpqmOrldaZ6DFZU+Vg4DP71F0/HB5mS/w+n08DcUtz28yBYm2E5vJmKdmx3EMCpNtQYo2rss22WYYtAawMzx0cDVugm/tU1JlxH/bkIT19zM4vlHkkQpqyDIE1XvB+Pzf9rWuhCbtNud5JfrnQ5AsB3FJSN7pfiLcZ+bvt5yLIi41eCx/hH0eVJL+M7W0/aOBAlpicrlC+R5/ZbPau7V+0RniWHBkSex7zCZAonKhgTLmXlRfi6gO1FEdofTOhTnj5Aj1szHLEv4HSTpKehXjfEdFgi3Ez+689l1yMgHWyFhh/BLVhUlw2GgkQFSlCNKmPf9oM1HDf4cj7JXQBuTSiR+B0AQ83LROTk6i8QEdd/bAUqCDBs8rjgXl6yN8KP7BPhoGUCaT9uRxK5NqdehBM1hRzTKy0yBxvzs3CEfG+k+XuI4sWxdDjVAT3HWQrlLpLfb41efgDHK06lPX5f8RHsKj34avVy+BcWk05RqXbWKn4CAgIDnn1QA0dp8bgUhxlSyAG4pLorM8tOJT7+Iz9SlAxEHaQZMf0IVTSa8cJjrooKnP1YsklmScrgUtJpsVpQ5SWaoWO4nqoWYE+fsXRshBiCWOOBk82kJmaK0GMZ3P3bE2PTP1C2/D3I4+1qPNOhMNq18QqsqCs/adztzfpw3FwSAK8c0wWDxTlO82Wu58TvjXsiiv2fUuaB3IqBtjEor6jE3jd9FPkGvdwZctNnHHj3+DAJDh8DEzbEPhwaEvUWkaCZMyoinmUcyZGvXnySOkHpTEFi+iscKGCGQvgtv7S05DYyUmPOTUYXlUVtMPQ8APKzLC0gOvYHo9Et4NPfbaz702dk3YZz9bspVEjmy29ToL4KHrufm3dIJ+ceZCi/fKHFVt/8GW+AFOzBtaWXA2Gb+3ZQIE7uC3HaJvop/4OOqi9klqpJBEtxzuBSY5yLBTBXzPv1zhnnoBu1AhU4e5fkAmh0BOc4ZikwRNFLxHle3cuFDsCIQzqqegX+XqzEO9W5EZw+cDE/gNk3qFrZgcHxt+xG1pvgQe8ez43XEw2FdZY1VZQhc2Kj0JmSQNJcV9X5tgPgAv4pUPun46HEABWOjwe1IDdhb117chPx80HUbpVM4GRQj8f9KrD4cU3lcdaSK4no4ykZMFzuyQjXtKM7UZM5wkIFFqSXVM+11QhkltybW8GCA5N4Tk5X9StnZhM23veavhzXMwFykd79XjpDxcMxOlV04HGMRKP5BBP4ss5kLz+5BY3fHJLe8IyVrNCZWsmGeH03/XTZOSS4Jz9qDiKp+DzVweFCrdMDKVFV8ftQjmBpAPV8Rz/Jfh8pUbs/LPhxjq5NZ1qdUzU2goTy1d1eszEJ0YZVOGPsyqGen+choZzlmSVY3I1zn07zTY5QvEueX4LtAuZKQupPshLhXYqxtr08RlJCOFudx41g10EI98lFl7W/1SU+2hQXfK8itI6gHlSoKQTjhgQ768uXuU2hIaxlRh4dsqW0k+MKwKyIO3l6V12QhjDUxJZhuKCvqUX0X250Xvm97Jz/ykbCsb1HVJSBy4kzOg6X8dL+60CohuyO0Yjk0pxWAlXzDNPE/cbPPocHyO7J2bhV+MJSb5foWhs71gzQltq+1uqoEU6XDML2YWFO2KED7YZdj+L9MDKy/6FbqeqVcrkA4fi/HPinEGGuM0DGQ0jduC9haDYHstwicK8hpz3uqoHVWP5og7LW57TlgakoP6IySjWMukxf+vz3cVs2bVtvtaSUzeF3fHXq0sRaSMMjxTsKuSION8UKl20sc0xFrk5nz6V0lCRNeR6pOWyoq/YAGCmJlsmaeFVhXcGgphmqnV5PTB1PdHeTpsnbsmfCjqYH8YoSwhwfMleSUHWg2XMjHWbZKo5GM7/C+TJsSalqSFwaDgHFV6eRXud0s3XNKvNPZtC5OB/Fs0H9EY2ZDgoAeAgZVULgiNKIc3EztX5efI9bQ5DWHO00dVlEhMHXUQp2JJhFhg7d9v3e0RThDCiQMuCZTcZFAfGHgYhdrwE1Fq36Np920UNMNFfSWMS5AAJhDYCSgQYLaW1s3dbdsIYwzue9HRgoC5w61qUTtOmoukbW7+eEl7sH7VGGa93h9H9N94fUYM/EOjwpyreHAFQhKZHHP3sqhH2/UyC2o/fxlbwOzTw+bk12+c++IVNlPev6fdwcWgqfYPYgV0ArI4z1ozCoGY9h1UGOl/4JKyx8C/mWyZ+RLRd6PfLLC0rcLlM6FAVqEe3X4dWdroqhpMAgXeiZIZ1O0DII4Z6fT7JoXZVCBmLQlhTYmZlOI2ybH4aDjmleJdBf0h03nviQVqe2tLri3nNQ2fr+cUCfsX/yMiOttqBJM0Y4iXEz26q+2hMXx04il0CVl7LZYYZw6NSZZyrUITklq070gAJscWm8TVkYm8UvKJa/ztBU9vex/69d+OxY01hg1lLchqw5TjlGrEBqWsGn5QuUOL1Rd5XGdYJrx6dUWspT0t/tmby1gzphO5NGkw0Cr0Mx5sVnp+khT9AQnv1i+IztnLsKlzyFcajakAgnHgpYhqxeHahuz+HJJByl5TXwixs7iHlIl96iYXmXejAN6PxJjbqg3eMuoDUjI2Or1WSyFdjZOSkUhDBGIFz3Y5g6obrbcCwbNNrhn71sjFNXwVb1Y2y8eelG6ELR/OtRgGz8SKy897IutENNK/mqmYcOYmtYNYPq475YkLH+VMJ9xViB12vVz2UPdSD+aojzpS3KKf8ia/I17ULV695HqGYf1EDYkHrWBxzKtyHYn0iZ44UMGyroFc45EcJRtMBF83GnNY1sKWsRNRoMi98rr9zol+EbM8m5chtjE10kwTIjYYmGlM6w/9VKrjZxepDJqskNbW1DmFr5zOi6GGGK4WZJc7g6Fx2fFLXxY1A2Yddcgeahb31ueNP3MOc4xdE21N2l4Xx5beaoa9frk+eGZxt9sVein/BTCK63G0e4siBaQvdp3i6Od5ecA2ZvvgXrw2giz067ljwsuj8fydSrlbe1eg6CNLltmHQ0gBRia5TBtiuyDoTsKjeWLtRf9x0o5RCybzeOQ+AftpxYA/1zS/RFVviyRZckmm3QiZUHN1GLjinIoAV2X6Mig0edGXyb4VEMUPmkI0lV6C7/AZNDlEkPbBnPsLOsGOinXEOuj7haCpKyCGDtvqDmYptkV34efx+JjLv90QkKvo6k3YBJcAPSLwV39g9XhewbCUvyxKH0aMlj5HzkJ9xPFqNewMdBUeIsmEJHP375g4DVANGbS27/uYu84uUalt/0/06EIg9K6ydwp+CxjVQkQ5M4smNj/KpNSrUFv6s7jwbeTrgRu57exl4zBPREj7fcYVbFPje5bNHOruboHEvqd2uiMhrm3imvhegOQZXNw+ApYpHQC+7Xh67FfdTgN75TegV7autnjqA6KJ9q3B84PmR6c6A9q0i4YBsDOSCcn3KkH4RQNY46QNio7eAneHuGA7v4IJJ9a9co7tC2z5vLDnP9JStBAjAqLdjsGrR12aHgiGLdBhILzwvhThHh46T3QA8S28geIxYoRPtcCxAtddJxjSlxQ32Vt5o1Uw4ySaqAN2yY20EapoAUCpGwICYcnczBoN3iZ07h7YLwvmqMMIEcpSQ0x892N1x2hBq6mx2I1H7UarDYHLFDC1/9kaL2jQg49eSTOU3rRZSLNmIcKYiQwnE/CsCFkkKgk5915zoEdBykxp571ljADU8g5XLc//pGEnSOcDioavmiWtrHErItrnsmzcAjtC+gtruu3Om//Jeq49cjhXnTh+tOGKsOeucSRAUge0EGj+fqXHuvT9+p1YVj0gzhJS76BnhYrKixxnzeNiZoukOjV65Fy/wGfarofTLsgFd11hyTgi922mIyELoKk25xCjsKSxZudi1SIWxaVPnTauEPKmK/OrEBJX3nhIxdGpKLL9ZGli/9yBJcX1skdCC5LIxPI46jTcSa3FjlDI23em64pk9tXJ3HQrsp2XFnzqxbii8OKapMVVe6jFCxSC8fg65JAyPo1yAP8bUjY+3b/CTXB+walREjGoc0y8Quzp2yUoLvRNRrCr0praybBWMbRrbRYwtzJ1bnoDb37Jd6eMEAl2Rcld3fgJst91jMmRhKFNGZdMsVrZ12VdVSth4ALp4wzxd+E2uzSI5D/AOoFKyGQgoHgOVhyb+hTbthToKevsNPXMJgM8V7+hb+mz1/1lF5rE9gDx2ggBSubEkDH8+TirzSD7wO2oaNNBWcpBj88NkyTh751PSJ5fKl0aixcqq32gMd9DVydD2N3Qq5xV2zQggWLAivG+6b3niWegikK0F/+RJLpdFkL5VjlauwDwDaz2GcefXEkO9n557VpmywWp1yujjgk/HNks479eEXoxPFAPZaTgp4IvdZX0mCciEVTlZT4RsDBHoudOr7np/m5m4WXskFxTndoMnaV5I39ZSlHzofs2U/8Fr6yqG+00+ssO+tk+20+n1FH37dK+1dAmXoiwBmFAlsMoRlVhvVKZWkbmGWGH0IonaRhH1EN66hJYPGOm1J74QQ0Xndg1ph4gLawmGf5V3IRcr3xoXqQzUp4/z+9IOF7brFS6NKJJoteW0W64FOIyajBicq4GvUJqq9WORpFHQJyZcz7qHGwHs0A1+bhUfopphiMDVYevJIcgGg+F3j4uVOsbZ6rbhDyJnaDOy+JwuDSEtP/Hyldfg84VcceQ6GCLZIznhOPbULKgY+W9mHmMtM3E0zrUQ0x/rJ0F+bU1IwS6w1pEIiDsNc6oUcU1R0zKrGe8X6+/nLIz9mrIaGR1rP8xMG9unk821RVeKOZH3RdFTjTVZbcCJRqlst+ovN8T0EM/j36wWI3e5LcSZdZSXZ3T2zqVHDFsbWWiA97pXxadebgydAWFLw+vFSjWa7Ubm1ZxViS6dJSEGRNVDb1hY/KB0X+nuXRcoxFp8CnpkXS1Nw3FoaQ3oZuZVtz5euxcoJz/SZc/drKOD6cV3j6ncGhFJiMRs2T5KzvtNQo20e7d/enJmHgQB6Y2vkHlB1DV/qeYLZIC0IL6/sGKdnvnvuTWHiQ2ECzVBZBFwTe7Pk9ThegxY4YMCL5HQiz/yOxGME7NDzKlZvZ7unkX5g1Yp50yzd/U2fZQtOmoWGEjIUIHjDiRhZ5mZjaD7Tg9p8XwlxWw2GvIOSza/yjqmXZPRammb3g6QX/WyJSWaeZ5pBiHgN0MwCyyl25EcxFgXl+4GyK7Dck5X0QnrzXpaOsoRMoba5coCbgyWrh15F6HqNoI2f6lMaC88+kel6p7SwO311pzThk+kgLXB0LnIbQGyULHdm9w+4VcoExVNR/FnPhYctt67G9rMh6uNEEweSMJX1xX8Z/C+RWvVzpuCzG5JBue9Nik6J7rwxKeQOu9zsbCeV6wc093vykN0vGS4f/LRxgn28HbbV34RzqrTeGbp9w20Vj4nyZJDHZBikmHdXcjQ/anNAyBZEKUFuTZrefRq9Y1riMvCfD68M5/DJfZh3VQFQFo7KI0+BTRRrJWEn2ocWjxdNL2QFuVg+cDvooY/CvwS+IA0KqD7l8tet4Jr6h8qC89gp3ottgihPS2eUKXYhQSOtuTDhBMn6UYfLayYcPOgaC/k1JTk1nNyxiZDK50cyr8Wp1L5oSFBVYiTQS3fbKxp/UozcsXpeYlGXtLTgaqW/xpYx22Alg2yFyT3dXcj+N1VpVth3d99Aqj90ijVKgZqaWPOoVfryAgB3VphoEFDJ5Ez6hxnoywi28LehJyemcbKTw/MwB7LORl01HG7vJ4oXUt2dLUz7Zol/YxYlyuS9V1kxlZQ/iYl7M4riNDQIw55TrWB1f6ttk1tl5nASV9ltx+SddETO1RX2ws/IchoxVWra7cEmV5oekswgR+9WV639U3jfRb2ySY2O7/oL/OlY97xKmDGIZMehKs3jn1KWO/Z32TvWZbOR4GjtgxhxmEwXClLihKxJhERw2U0QUrfrGgkphpnGFXU7s8BUBgeyalurRPaLEqB6Hty6IlXhfuevf335mZ8bqSMTK786JE7wNJKz6ixQYh3C73XHz0NwdNqLXh4endNTyKB/8gCUA/rIm6TVxiPOrIDmer/heDtPkmJq8R77Eu4cxh+1ZAhVd+TmMMT5X1dMzZA1L90aYkSECqYFNGfk2Z5fZwZO6VRORdLPsM9Ke5LJD8Di0lpWiRLncdlK1TcQdRIHV1Kc8adpFfKKjnOeS/Eb1XwHurUSdCEh6o9vQOkKHjHAD7CTltAVm9I6Ss6eaPln8/CoJv5MLcm1I6a1Ono0lth4UCYWFyzVTFAdlSWYv7ZQ1QuhPfJS5pMDcXdsNlYToV/y1VJshfi8g4JCZSWmqDfv2+6DAifYxbg+o4ASIIope2TejOfqhno6Mpm6KdE/A5lo+QjSTF2dHLpiXflSVFRbkAiX7NuLQkZDbumow+Np9hO68LzgDhFouJT6zW+oJQ5wlNXj0+abzkxOU0vbmVcMWwT97xYNHwQHQK3QyHbAtHvg6XC1OziN6CZ5+pAvQ4/8wtt+KO9oq24OrJKcLXJJsDdrTG3CoGgQShSDcCSYHxxODLQbDRNlJliCp6tJeQF5IoHqwYfnnj2Q6+6MlPtgx7SIk9FaBaFhvi2Mzensu7dljxqP8JnvLG5LIbUrUCPrXkEa12WE/UaxuHyjH0LxrBVDyecvQegrkcJtvKMWYHNeiz56xegPgrw8hI4Q2V46HkwyUxwzj6n57EF1C/TAscx5F8aVz/iizxVLav3SxgKu7tGfLAzoqJlSJBdodffkZeLIXyjDepY/c3CGp5QBFSt5/iUHqnytrBOKhEbgOr/dDQ35FQp9J6pnYzFIh+t72hVGHIIytHk88WlC8Hg2g/yFotQoqZL20zSBQB+zNH/ieCsqITt5jgSQ9MiYIhdGEwc24GC22X4UBBwUnlnWMkLTcvHQTHTffOl0DtYK3vAAcIQDa+Xxo91Ld0kOW/zFZikNxlTEITU7Wc/Krlz9TtL8LRpv9cr39HjM0m/8y1QvMp1VurnLgcylj+9zmuZmweCPvNy8Se01EwFMu75nAK62+geRpEqdp/NTRL47WjPTthzspeRmODtSM3d7bgTqLjKQc5Xk/5GHudSRiZ3eO/xZlMtUskX7infD8D+CnYW2NSOEA9l1QUr1TmbWdhuoAWTJoN6dPZMMOqgovd6EtmigeCWYKcG7nqWnkKY6hfTMb6OMaEjDrGVwOaoerAWSpgCtgrqQzGazfhhWwrJa7mLcHdu0aFtt5K67GQRjtBqKBoxmAySAgy17fzdQjc8WtTQ6D28u5EeNw9CayI11q7wZib5xWrdqvHJMpetwSrE/2ZHzarACbOY1vyKcjRcotmgJMSLty7Vg38Cud8RPWyh+MlvP/AitoF+8TvKL1fs6+JRU2dAXVi8TGQmQjZKRxpUAsc5pHM8JiZmzVCMnI1EFLrVT+VBCMbvAuFDMrI6qEuY+pIejUqa7kMBc0xuVg0pVu9bu1CT4EhUYYV2OL4ft3PWz9iODZvCNBMub6G78UT9Ij4mexMW4uunC4vjfzk1WrCgt6JW/tnj5xpOAIbLQ8aU/827wjNsJfZ1NZG1FQJFuzqLm6h3TzMkzVl5qFUHD2AVI9R5lnWhqqUYYySFnW4cvssaRqdZcl+HE21/P2tRHjLXmR7gtxTIzFptT1I1V1w+/CgSe3LNHjS6qYNUVlLz3DMEN69KzinF+rwEZs0lKMGNu8WFVPoQC03KS3VKwS7jPuzkiM/djv/MWG9zB0iZyW6MOuqxIybgWS67lk5reKcFsKNOc8fnvH1BE4mTuVOnEiLwZzdJX+rFbQiDjpQcvJSuitpBsQLDvOW/z7jt48D/1ttNsOMm9DvdbWm7lxthx2p/b0guPy38BhV8hgztav7xQf8eOTrImbZCImBpumlFjYlFY+NF2+yskWctnWOhtM0Tpp23/I6ZVdlH6c6/TK7wahfqEnuvvXEgYiYA+qgV2gOOkCGMLbbbZkh6R4Jr+YWgBXXOrLP2DClngOECxPuc5zBE3wjPXCzFwf+W4kBX9rGnBQkwEm9kHLE+rz+qORvtvEqyEmOf1yEAlyOgUE9GjRtYWmL4UNPIEthU/kI10i8XtY3SRIaFB5mYdwe1zX6P9Gk+2wOdw5JUgP+jJ4RSRfb7rXsbMQmneewH+6AXfGCpLyV0jayvoEunZ8I3LGbf9RQVvJZ4fCvyl//m/D2uElnZX/QEKWElL9CYe9vxixDn8vZRI5mEL9K7bBtQWUZ87kCxAZHJcoxAgl/hX8ryAtdS6z6yTWdq1kdneRiJ5jBtlIjZ+ruvM1D7oNCSVO1FXUmVcRAYGRa3HF4cYS18H3/k21s7uMFpr9Yl6Kbjzbdz5qBkr6WFBmMeS7g8Y/wENHYEjPUo+bXfZWDvsqPYlFWsY1lEgqTDZCiDLgHqZ8xDWQhMnbodLd8nwxwuMtVcSVZwWTDtAVk65fBKibh1joPpVfBg3VtpOpe8cOEj2PaDtEhIveWWDK4qlfiiS8B+IyGj2stGLT5AIykBnZVf0e2rTjn3aGUgeWVEUFLRtbR7w2+jakAPu3nTRxeVZUqm2pSCbaXmXKGsQNfnu96tC+q4710GeAHNBaxqadNB3D/W1YgR4bAZtYbTXqpT+pDub+w6W7Ou+RxFVJo7n9Ir5+3ZHl4n3TRXdbwPdsOu4igzjr4LjqpOMwx2uibX1L4TYLNnCtlFTIM9gcGdE9DDBCacQrAMqVYzxHzEi+6Vq7RsLa/zIMqqi0kVPfBlzBQfSJGl08gxRlPyO4umwzjSwyf55EGd2zvYZmpwdJwkL3jDUJpiaLd+bjBy4o9XtSNXzYzSZBtG4l5zoQeKPSa/kAzehJgM7KN9ShJxJAmAFhsdckRGbaeDIfioehEIE+s+0PhBkrz1YWRZakAc7L26hLcLN92h/6ir5P14lnEXxFP31jEdzKehsd+jLlB67nQVXMwmg3s8LM9/llz0hG2vZ9ClQGlPE9dLN4wwEfE/4Cv1EEAjXbBtjS4evIBAo+CRfXGnnskXkOB7KGZXdutYWtxIekjjxqlBGxi1g2o0fKMTUkJlIsMyuFwqbgJO8yW53lxLqwjR3LIboqYTo+GG1PZFL7v49M+1aw92Gda0ogBgmTjpLCFq0I843EquO7Q77TmRlAhkvKfQ3YixMp7tQmhTfJzwn80lCjCjV6BGk4VA6AeyxkZQyhXln7zy7iMqhEoYrDO9HUBfCDmYmCT9FsHALdNRs8oCABs/G70hfMVXB2azGxWd9wpg8Ks7lcs1klBTxEo9bUVT1HCzNZ8nVWZHljsAVWlBeE8Kuj8Onk1UJ6AsgZ7niSQgd2kM2bE+Pni/xQ7JQKJ03g6mc8kZvu1nJnK5JDWHFW4BsJowAN/ys+5+fPZ/iRpUvbMdAjzF+/ZuSdDBZlLQUXAJ3WD4RcaJ3lm8zzUv98TCcDglSSPwp/fEiF6Rn4O/QJTQ2uY3MeAEk7oQQK0CFxWCWbl1Q+aQiD3C3hC+2zrr/x1Rsxz7zptVbnZ+ssLs1PJrkfQ5qfYZDYad+tkfQSD8yYUrD5RCRO5oUQFUEyWXEy7/O7I51N1EI0olkgv/NNI0VgS5ixodwrwHEkiHYFjaKFwz4SnQgL2eTGOzWLKdjt2qwe0qgBDLMYNEBnziztMAao/HPFctON0gpBq0krpDMoTC6wT3OKujkWQhDT4nH2Q3r4W6aKVW6Dupr67VdMgyYU4yqVnIk7ScjeqWkpTHikVL8WSiv6potnMj0LbL8FoOLCGeu0AteIHBmrHwr91Fpwu25ImoMzAvgX41tTXp/zEH76Fzz6qvMVMMafUpOtUWdJoLdZvq7FMfbzGd47E4zfMydShDN5RNFVQtef7nwXIdsYZXtUaXgMJmohwzinTZzYdxxYKY+WrUoHI1ED7JRRRm+D3zZSItQFCZLUY5fUv/RnhUHSoXQkkzbUiL58PLRnukffiYraDMoMMMHYKshbSYMwD4nFBVJMlQA8r9s1RQ0CAk5FL4anPWfAF+mVL4lSLw9pt/Y816pKNTCF8YnyOayfDTtmVKi8lkTQJyXY8uhkiGTxWgf3thQmP0ZKzzLoL2FkzZx/bOQ8wbiHrZXz2YR+JC7xrbD9hKCnEKyH+VNpARqBBN0bfsXNK4AcBrHhS/Nyg3W3/WHEsYyQYwvowAtdwuHSdKZZ9OcD4GKObqaQ4hB6qcRgMNi8DKROEpgZ4naREZnYkScWKN+eDppXreyrOd5JsQzW9NaZjefc+25pulDfL1FCmmBT/MqKKrIt74SpcNOD6E7oAJebY3D6OSVBQXUCJ2fRrWY87sAAmLbxLwMRgo7v80ozTMZ+9gi1anUrME+YG2EctZTOO1MeBhyLSwWEcssoz5ahWQF0mu2oHPW91RkDw1TDV3kKCuGiLiGCWpkexIU4l4n4r1dqnCcxecZUlONmo6yyWtihP0SFdbnqeD72sebEHt3MBtXP92jJx3Ui8fjrnevMpM4Pbrb5teK+RwGIqSCkXXZiJuJJAZX/DRpVStjJDK+FiV3Q+L4i4dM1GEcYLMxM4dDNEjFy+E+AWhGOoKbipriMWCixAfVDv3vCzJeX1st8Hpv9dYeBhbWRgRkI98ioSZljH39qz1JDmqQ78Blp3DsO8VpGEGofrua68dpcg3Wvir50OWe4PWTeGhZ5n2e0cYaMya8/L2pCZfkfdlAJQQTNVHZGakzB10zALNcDpRQcw6chhC6S3ilyzD6weH+MLlRe2Xi1pAO61X6gpE1WccyGsf8eP/QRfeRSAqTW/tkdzWrD75ptNjAL4wLK4JBzpCSaq66ts5YizXZVFQducRR25LNsX9lK/qrmpsbHCA6l2uA5l1jRJwIvfme8X/Qmg18p0bp3CzmCo9q/O0eCjNIWicuqP3/KhYXM+AEbSqb5P7F/uZThE9VGGy7DK75/wsj21tG0qdKvp8wOOs1iAuB4ytceMwGeEy2U4UixeBRdN+Xru6OHxZHw+PKgHTi32GKXLYzHcOEXz7ZtXyctMpnUYWyDNkpzHXC9zr++qi1Fjsjxtp1SPykijBXmkWrQXjVJ0RbE265ZMi2JbCfgVkPkDKzwpdAa6O5yA9aOhcU6sbz01QqMs5ZdfhnfA0nTLP2nWKUSKGBk7DdkbtUjw/mD6sQq2YAI0DJ4z/F4appdvuDRS657DE8W/jw0tOvZ3Jhc2VQ+8oA9/ewi4nsAG53hfvWdnFJufn2/Sc4lvdZ5aGMBczsGPz8lHt3I+ELzij+hf9GyXuoBrWBUHa02BlyVk1pC0JrrlPrkrHkL3ylWmKpVLv6zW09MiMUibylzfwzXLfZjhzvPXtFCx8lRG5yO9wFheitpXZrxFE0FhNk2lLdJtu+S7RcZZLLiABLMXo8fovUcML8cB90HnBH9+JxkXfHGczYPYkvI6PzUu9JikON8vTAZyA5c9b6/fHEOn4X8reDgab2GG5XaBUQerzar/mxDToOqW7DgLvLMqasgbrZbKWcr6Hxt6rkcciob5WnDEdtRBZZIrOoqgot/Y7QwUd5u803Hze9eRCr14v4Wkpdpiawj8Y/iPnAvZUZYKYEqx2Hw/XOZC/Q/C92IAs+229aO+nYXldFHBiBlni7HVn0u6NRUUD9YQHnr2ySWxnJv0EcCrCYYPrbsxIfY5O7KptnNtM6Hek9HTQ9JgiJB81WLkgXHBOXIq012cd50f7eSztEj4ggmmNPu+H9bhjRNy1zamBKAO9RbkA7rjsENAk9XiykBSUKsBfEItfzgJ0CquMobn3Fmf1uWePen1bMLwHrt0tD33p30pI2LjvGvyCTl2WspgAlQrLLmKIMbQlB1behhg2vsEC6CiHOdzLfk0p4BcFe4g0CPn2JFz+rwzfo3tZXFMrTcsNqhlueItAMdnEKxGC8DkNbDf9y4DmYPX6rjdCDiWDLRkNSmjowGl34VDyUISX1bHUOzS6Vi7SqvKsiRUAPn+3tsglNRnFoxBo+ACInspGLrwHMuJNVBa04yXyovN0WW/fwlesEBfpOPlYx/kri1stKguAsN59hBrYiklg2V4TDlMFMyVs2WRDB6e+doBKS9WqEyNpnmmQ+Vre7Rcc+Iu8WhYBS13CLFFLIuJuCXtwpvnozjkfmJB5+Jpnw2D5qWwkQGNR+XIWdhP9WdxFUo+xs3xeps79OCTXJvaqtkTvn7J/67xQ6dNwCWeDHiJzxPmI2l4EratGFOyx47gf9eMqMLbYwg4Mq8B+3o6fUxOX+HlGbJzErNmCEv85CCEniZDwwozBiHpKj6CUW/0Hzbgbdu9vXlRTeSjMgpwyXiwYMwb7ksfrA6D5eYVBQ4qeMlIGl8I94NvOY5+430NGM5S64W8rOtkOccFaoIhozuINF7DrYuhjqhk1pt7Un08/MpEhMJskfu729YQFML0lS8MEHjkxzIbPwqnvsubwOjmQQRgLh3QswmEgAS0Z9dzj1kbp3xLgnlzLFjf+b/DMPbro/I4yz6RdeMqjI86Tj+X/pKeBiye7GC2cg2UaXOxJIHlgcjYE263YIjvxb913RUaxZaDv0F2v7yhgC2DUrgulLMpf9dmIg0mvagwCDsy7ipJfEKkoGqcv7zTzUJBs1gapNx7jFTENhjrcg5gBBHwseG0/LydoBSu00LCes9Wfkqo7Z7z0dTngd78Rh1FfdfWKbZCB1sS5XOWGLYAvVa0Hlf0dS/hPORdMlWZf7mfpv36nQTBRgCCTJOSuRd3ASPLGWZEZenX1hS0dOkv3LVDFygau79s5kyypNe8YmEThC5eIThVrRrA8oKy3uVfP5f+q8eTwY9rTErypPfBor80/uIa1xLqCDqusQ0SnMiJur8u+NMhLWy51wQuKyGpHUIk74zmmEgEuaXuYJa2Kx+Wqo7U0nyOjWvgIuBYDeGbToEP0Jpf7dNRiv0ZWnFwuxTLpzQeA+qLnsqr8Dk4+uO8jpFRg6uiyOkbV+ZPkj7R9oYj2r4SgH5CCStVpYEdFb/XAYcd0x4xBIa5KMP3w4PIn2imzoqMA0grvA8/dHN1YiPOv7eTRxz7gpDOnh3N64Rm4Dhb1Msn2fKjhFbZ5v7xzJZaT9zFUxXJWT1dUN08TeRbIZr6gROWcoYDjPe7NBDfHVYkkgBeQriqA3VLxcdzwzKLKZ/U6CPbH+aFYkg2hgT0Fy5qYUHrF0zaVU7sULSoOHI4nrLV9GLTeg/kN1C38kPkAhdAhDBIJjyS+j2JTsjgNFjHhHr+JDElLO1SGvT85ihY/szx78Y35T9vX1ChnUIDrhSQQIf7N5OVT8VTuZAn02IkavgYrAIYoKv/bEssOkcPLWf4ZzpRbYOWOTVVjy4tOOTrKovgoXpVpzK7gFHXZmoNWv+k/8SFG0uQX9v3p+93XsJY0v8mrLRO1hCqgcJhn0a8XfMExM4f/ockl7eM8chDF1qcM4HK5n0lUOBEkkvJNNRxtxUxMVOy2y+HrwmYGEPUlpk4eDDo96zuP44ItnaXvExCiNaYa4Ge8FMJQskAfO/YNC/1lGEUj6bXkxcwmnjLYQjiL5aVPpKedCJg32Jbzqi0w9M2kDYiGeCW7qz6GFga/IbcV8laSSqlJN014p5c4blbM9p9E9jDnNGjJvuaUDjAqSaqF3PVPny8jm4iEwXNst5UVFJ01wN9tAEb4P/XO1Asz0xSfupwC9fWc7C6sESFOBAoQxvYVUya4SnIc021oLM0zkdK33IPzud4ztKXelA+pm0j661TxwMraUlDC57KpdWTQSGU77yjb4aTi615Bir0RT2CJFVi/ZQtGT5gW3bJs9wnnD1CT1rIGHd16c0qKS/94+xmp3q7U5iYLBVxIC1jEl8Qiq1t0HJ7NJio9ruID8flPrNZUod1CdqOhKWwlaYCOYw4ZzydaeGDzVc56G39uvqKn4nQuYWCvd90aIRNuAmVzKMkkdCgSyIO/TzwL9zfYUXVSbk/eEhchfl92YaEWKbbY75Ux9dUyOSAkZlfoBDKLeFU3vVWQxQPKt1HT8B4sG9sm9J5ZaU0awNsv8W/domDty37tFkjGrJFIfFfy49dEQZRhGt75OLXBdBBctFfB3OOGynn88dJOfi8iFKiSg44DFnDiSLusM18dFCNnOgbyx1B+IFQndynwN5gxX54lYqbi3D94xotmLnZK/8QrTeh2ZxzQ5UFV/merNl0OFrdu2q7HeDLJMX8yrGjXoZytfKwfxle3U9SbEMnikoX3yHhIj2k/wPSzsQpb9VTdaxX3U0rt4Sd87xFb0TAFEjr4zOhZzfQDPdsunhhO5IfyKH3hW8/0zCbDpG4QCSgOtF2/+GtJwdQOm/AXxXb80eaUpqxyZ781pLzrp0/SpWiIYcR6KBSkmpSOLqArhit3ejtqIbva47AU6vSj9ueuM8FN0AS8QlakUmNO9+lJucOkzu3cpI7733mlsmMWUnuf5CZYswrhSCLyMbORyJhQ+VHewiwl8t065o9C6WcXfaZffuuKNDdbv9+TGT+nxUjk4Ja4LyfDaOx9tPeOeK46gMN30Icc4MREYwiFDQzRUt9IW87xppZCpFw/xeJSz9/TlGA61L71lMemyPIJ4tzzaDYluEvIXyl0JTD/LjC/drbzgoonJFI/9zGJr2vKHLcmUABmyO6d/R+X/CKYXtqItNJLWNtumsZ5JvbZoHEt25Lh+qw0kO6yHduqZ5LzqjMIezmTBaFhdBd5y2OatLOFClhIRG0qa43HaAj2qR+ytG4pjuAL0r5fWLEYWm3aJSCRVNFoArgoCiZEFEzBKEaWWKfwCXxRB1l3ullBHqRklPsowqILyNULzNkNSXwqX78KktlsVtI6EdErLUG47arI+fi5o72FyDNBo5PD2Kav+BZ82a9LtmrmNXmqG107TPdDp2BEBne3u5Ko9Pv3KqPKbEOOCNSUA7NdoWWCVpcIGb+ju5PisoOL8arsc0IIdc2krvj2NZPTkGm2CRdUQcPM5aGAohOgbTWgvOzvBSFExy6TiWIN9fRUnqJw30tIHXQZkyDTxy3YmK77SWU37r88PPOhYPMR04qsRBk+ABtXpvA+n4c9aMhXD/OS745TiHpkX2Re24hOkfXM0k0uc/8IuttDeG6mRTf8BPHrdaztSOqR/ZnvM6AlEd0ciKTcwGIlywkfwFTHnHLPxeEgvFyBaGzTA0tBSB/ktl4NdoIgAiCF8ZWV5OAdjTB3Q5erPh3cNUewyapP2qOK8gNNd+g4eEkuYoHh+MhNsvEDCwndQnMfizz02/fT42jWPi8rvvExcd2dAnJa5D1/igxvP8dzL5+tcqK+SKe4TOD+vSQgAdXPp8LabkwoAzwUsK7H5LXgwCT8KqBeT1qJqsmrKmDEDg7TDapMgXU50BTAmfPgJSZJ01+4mfZ4sVFT1WVrjyw/gEFdSK2z/F8IsNCpp17wtZYeTKPvVYRmJKIMl29OIApsjdcpYoyxf+ngC04blPaMIgSvfESA22Tprhcuf5gg3/OEs/tHsQcAC0n1gjW4v/LlmBwVc7+t6mslUQGrw+KLmDw2W/eB51QvrSzpUGd+J7ZmDKM2iTNsXQTMyMCVEhtTbKffKov5PlAbdUAwqtfHGu5GvbnSnbiM0lzk7SJ8YY1P34J/slmeIvC41XeJ5Y2J6a65WcBtUwG6bnbZfKRvQwJzUbGECYbdstTSObdJhNEhLCdAJn/2V2xfLq10LDrFGhLB/OVM0Ce32n8VthU/tuP+ZCaahxPKK5RbdymTN/9d3T8+KSRw/jE/AYyzR6iQ19vmNepyebJAkcSswXXcXXdsT4DxmLt+gT5QjNwvozJOkT5y0El/UVJHNAsNzUbqhD2MrOEgKecdc2KO2rtjgCkfsByv5YUKnOdVfuY92hVGP/MHkrIqEw4PghOcobHsgb78qaz8R7c9yGkjLUUduHu/ap13FkcsJ8ydCQDeL9SF1cQBV31P0TdyZ5wMXwvGLwLGQ5YgtcKAiffEE8KIEnPycatRKrWg9Q2HF5FPNxMpl6A4lomtxJaZPjrWHUu5f19cqPHAlMn7b+n0JYSwX3S79WypCjrmD8cAXZoRGwGIaD+XkWxWWCrCu7t9/DzL1dKDzYfS/e9ltgrFI5x3arzaLuhVP/Xk5IbzKvC7WGSXObwbPBzUm+XD3RYxO8PAvAeLrBDGwAQKuHfqwdZ0eYXJCTdo979yHuU3zU4XadLMPMH0G/KG3iMfGvTCQD6lITj/tW/Ac/pTJDZA8I5LGBbR/5dE2uO1YykA9BdUA23f1oCQhCKHaiDFUKtnyGJuOUvu7ZGsXT3hAS43fEq2jSXaiZc59vHYCJdk07ZRvKFQEN60GbWBxZn3iadZAdpiLQXu+FbmBTAtCeUBXO25ld2ZPt65fkW9jvAaDaFIS1/MGCFHPGOFvxkusxi5hFjZVQmcwwgNBkvxuQItjooWWIOT62yKPTI/8F4DpL9M/K1O/QMP0hXGH+cFg9Fj2tsWRDRTcCeQ50gksQeSGyGzkgPELei1kIAPKQYdPs6+2ohw1iRT6cNgGQifcX2JmUxInbidsBvDArhkkeIRvu9wf3R82to0VCfo5LgKN4RkjiKNCMeNJ3wPDXL2GE2D3/Nvlm5hFGPO1QJnbQkirgL3/9C2nOIlNU0Y25ERZ6Qjd8xm5S+x57YpH7IxomGXAVszP6JEnDRDQFlNKEjz/eVpICJCp/OABjyTOyZZSaZfZhJx/BbTlGrjCAO2c9+OxL2oCQjheYovnzux+HQpkYlgPRlzTsDx9yXaIqizL16/TR3P6SMF7rAzdCCWMtQMcjIs40Ogm3oyZH8oMPu64L5VgLSu+CPLgkyQAjHechHlQ3Brl0RLv0wcJ6vHYBBLAXLG0W3OsC7/YqPuoI2HIFfHkRSm2c7l5PDdQ8dMaExfc0K057AxxgD3NLeLf3ot9FBxYgagcCPpY9nSkPBsC5rq1bZTw5vN/WL1d4wEbegWGM00m43ByTeCIVVgFcmUZMgym79luzttT7VLEW1bN6I64fEMHv4WpojCkvNdfrEtda6nLco5NZNV+mFF9CbxpL2iQzF5lnUefQcQOfWsx3JDd0Va3uQLqdReJx+vWVzHrZoJ80klW73oAGdoBvWv1+xdl4XE4EcBac0eFtAL8sIuGP6xhVY2dTLrg1IGpTcHMoB9LmMNHtTf9PJV2xHyJTP9yO5uyYwn7RH1qtUqs9FIuF90Dd6Xi9+zq05HUp/j5YYjYeEi0i2kjaNKAdJQ1yZQxJJh/tZp1tGt6vZA5HET8wvaTZbIO37CX5o/anavJdh5AJD7LYh/5jQFKloWCrD2u3b+4d7dwfZSJidV8X7NNb+rnaBZLNrm7oqQEOHaKvQaxCZL9gEIhPONVfDzp/Zr01VsBqb7PCnToO9Fyb6hGODXHyZMNrN6JZQDq1Wj+geAxDz2CzHUWm7w90RpwoblYEO2GVldHGokKN4KYhy6V114PTOtTdlBEXUdVYSfy3lEJIesVNv4x5pV7DoA9p26W735jrKL73qn09u6/49eiQLsS5uw12Pae+5HMkv2QDjQcYy73ixapjD9deINY8MzE8NbNQJiNOrpdA7Zig4RWZckyOCcBNk69pYjZqJpHR4oa49MpDLGPkjgReJoX9etQpjO0nSfp4jEnljVyR19ktTLXEyYznlDpN0RpbW2RvIHBGrUPzYMOfhujzInjY0OHpHjTBaybbNyAbXrAylUqOBwzBhoJLYNYpmjPkvKx9TjcIyAZ4jPGBBR6rA4lB7OhNQ5vBigLBmTVvlWVkwaTf4rJyyCwJQQP3k6XyOjfuBf18rY8SFL2lG0H7/1BodttcHlvSbdjSJAwkSYqSAU31MmBOvCCiA/S1kt4Zm1yVjvN8RP9gJ+JKrv94Ki08wEsiWY19SW7W/Ct/Q2BlSNhVoWJISLnTvf2jF7jt1SaVVnisQFWck4HkC8SkCjtqJZogug5udnovlrvqn1DXk7H+kkRsirqsv++faybkxbAEN4UPfv2IjLEtp9qqd6gm4eJttDdkvbD390Ra6pQe5sUfwtjquJlZjzqh8cDy/BdaLKMkV0pArX9m+u40R/8BcprqUD4ccZgfNshKQF6Q1pml8R4TKMqXI8Y0D4jJq6DFh0CwqV3iYNxVjEP2n/22FrRBSMEV/2ZLcpUvE00PZMkG5A343lSBd31pOB8zrqw4Af46ljAG6WS4XzSB7ZJYr0evvmSJlS2+vfrb4mgE7YEk1hlGJavKqT5ZqMt8E83no8VMOxroy81vk9tgh6U/JVHef8g0LGYt2azBllWgM/5bcB+kEHMOKeCr69guiojKhJlJ47o1BeeXx/Me+ckkt7qEtziYYplYIrXleq/Ig968dJgNNIoX7iMZ3kXh3aW5SmIWgoPL8D6lzSx4z1K0oyowP8iVRkOfCirMwQqoWfoZ3IwxHc9Z50qkJGONrJ7nAlwrtSeavthvpEy4gCKfHyvr4iP9/ObkaxjmX9+tj0zFML7sYfMEjcBz4ndapJmJmqWZk1x73G51ZbZVm9eC1T/b5elKvDVk7cXcVkV9AZfGHVAWpl6pnosmq20ncBMi92M5H+qgx8tEMp8VT6wh2f1aCmp979XTMSvKyhPxo+s4gUhs1+2pNxD/RhXm8zcIv3Ze40JFcH0t3cGEbTI4FsvIEO6t+P8QfyoSPscSiGFCU21/zS8ou2bFR9ibutnWOx3uh5/v7qsHfyNLl897wi3EmMsjGf8Ann6/K8SuIhCEOqPgPrcOqszuDRff7csuKYRs45lOgUyeNyegGIbpsQOeT495n5sPAaCdKADn+KlD6QYrK5TJB0v4Aa3z7X2dFZU63ZouSPho7HuuY6RVzBKOC/fHZTPDSyn7kQsOb01CkXe+RS5g8XCsjm/6hkDh7BFqBs4dG+4jZM7A3XUKnNU/nJ0yQWPRvvU6HnOGMbDIOvZ8H9KTxLrdF+ZixkkPrHrRi001PgC1Io3KYme/maqCuLK5k+V1dzMxZYOT7wHl7sUTpO1auof6Hj2Ye4eCAS2CLCGEGVDEvumSxP6yHa2ivAra+LyZO/85qRxqHM6m9fWuOuulH1QS4AL/CetnqD5aMbXIZX0eq/BLvGgy5QSwHNkBSOsjEudexWM0v1nFlmaFPGhSiEfSQKcVjFQ209mv5TjDEF6BEZRlJ9MVKSulLTPNNYlxCz5W2GP24TGd3QkUv7c4TfXGu1YaKJUV1HikMooH16qpUsyiIp+BqZwamodjL1HbF696BbjP2T6webSDS6IZelGOJcOzfbpgcPnSdaFIkLGVpoF1ZykQpdPvqHRufNoPB6sb/NTdZPk0Qrat6tih6n78QxVeF2mtEaGl+YAvANgFb65lE+cHrX1H1lGWXzuJtcOXb7mD0y98jw9bb8EsCNOpLoXeJ4PhibunEURfUV3yYcJ7Kj0feF3/KjHIRJkbouqQ+aD3V1GwSzzYY3ELMUCHZLCUDE8GhhiluS/3wh6TH83O+MTXPfIHo93iARD1ES04bT8LXBgQ7UuW3crBqokpshZK7M1thN5dxqMyIumDoCd9WV+m/1O/GCdnXxNaDrThHxotUDRiZ8vZgvNiV0KmT8LF7/1I3eRYz2TWzK2PzLNqEWf+gNjzh7yRZLGUJq3DVWGlPjro4pfywpI/jEgqzPlC0qniLcDydIbfCwu5ElMJgoHCZp0fB78OquGW6sfFH3fcDWO6ZRrjf+0atnCWpmR7uNbB3BvLJWq0LE4gsu7Q9ssB6QZIyULCX6glGEeZW5Rm78fkzLJTBxCAU0aWR3h8MqRWEKKGd8H+3Hbt/EzUAo3TQtwCIl4dM345/TlBX1s7JRp/QICCDnTtp24lTo7fA/oDG7vLDN9l+fcvAaHiepkTOm2yGre0qqGec8Z29jx82O22X8kIp8kyusosJOQPLupGtiMui7SfzWJwqa8A0SKfYPmitUGhXP5TTcaUCEzvypzUeMcZTPWIfwzDgz4LHCFzOM0xSYBvpVCoTtOEr+c//H8QOPD1mB/WzNG3nEeA3Y7RxPw8srlLc3/PtRe1MsoJMWfjdnqgu7wFANepybAgxJsQY3TsfBtY6goE9f2cLBr8OWNLZISHF1S5LdIxZLPYJhzk7d0k9cMm1ulTFnbrjr2kikePT5RFUzTzFFZUrhxySPjIV2HjmVdeTmt8/1T9e6z2nmHWzfx9D/933dH3Twbtly5+j1CTgnR2NWP0vIV7Bc1U7BugLukWbW88LAPK1aS0K/DyY++xyKdR3RUuBix1slO1fRSAtlnkM+3KG0SjGyCWmkVLBp10Zty9HLCZ7hW/uu9BC4+5uEA7EQZxNsl49Ya5SlcYT0ppCeCyzvsM9K+1HNa8lWUHDCHmq3Ammqo7X0dIVli3Q89B/nJuU++Vou8vvxm24m/c3Y9PsOYmN/D2sliwhKjxKq/1R4F+eurj/3Z/LYDHwEgOnq6HDieJSgW/ymcGaNtvPz2kSSUGCR0rTFeWaFAXAxmHsKpWqneJVYrrJFF797iVzwUxuaA5Uz0baLTFOjaIa4FL4relyuUc1omDUmhsYdzgGmT0RyK4NJXt1E5mgOeibTwdbCIlDNCInnG2PZNYIE4nKEwytieZlxYbpAmZrhxTgfSjYgSshXMAJeEvym2mpN3eO9r/Ll9ZQE2OKYfxs7sE1+mwh1OhRZxAyVxNduw4B0emJOGKWDAVySuFApe/dDeZUJ618lpHH0jjmok2GMtb7Op6U92qCRYvcJdQKmtCC+edyL/c49C5ZYOvub2rV2Hiq/LM6PmWgduLGmRINfVTz8uQ1pRK4zmVG6rb5WKxfS4np0HryBh7WOvbQwwIFpk4O/Gv9Cz8poWQFfKTM8I5JZGEvrFvGH904DbTqR6QRytfMWhpvNZn9FVsj54/IGAaWBTLd07cLLR5ZjjnKhVDwKS2vLquuCn/SmkvmP6rvLexO+BHNDWCZ4IluxnV1+sIO7UCpm+qSijCxcdCa1XEFEGJJo25C8LNNsStw8h5DZ9mv7icFOvodeLGGOGOyDbMP1ypQ8MkjUvFRKYWCajwRxVlhmwtzKx7qjmOt0S1RjhRsQjvGjYkweA21KF7ssm1FgbKJxrJWiUs9j3m2Hw2wGx9C2TcClO/RvQNobL5nu+tlToiInixyXgV2S2t1mjdRJ8U65q1cAmAdnRYeXdTvIqxDJxs0g3E9WxjL6idK+l2d8c2hvZTJLKLZNc5r5fgPfemLaPDynAF19G2tOXYNubOxSzGIvoHPLs7zQejhufx/H4J1P4EYK4OG8xPFEkvG/lC4PtAWU6KhQJTNib5e3GNKYMf6wj+4cHN2nB4ba8D6yijjwOSSEiFbXzbaFg4ql9cbGT2aF9syb8ZkXiFLXO4j23xaXgOBrxPqH9lTjeuZg4Ji4g4VmkLfltx3+T5H+5JRW2dRSQnBou3fbmAsSRV7InmIbMsvIYKs1SeIe9CQeepv+vkASYFoWk97oMElDK4KmEmxzBG0IjrEKesYPzs4NXpjBxt3O+kAyNX/wksJVR2XStyXQ4C3EPZutgac/CL/TMAhaX5gAxSVcXrmfevoHSKMTJtOfHx+ptWviJZ8WaAc0SSkoPtTS29sLRtgU8EV+qnDZQbnNbNakN5QhmgKHuJ+DnL3+tYlxbMZ58JFUVrUUmD1LsIOWiG8l+T38/LGoVlepBIESrJev7tsUvMaSIbgEfOVXwLB9Z4PAt236p00ZWL8wbRrIISs+iAbJqtkCs2/yib1RsSg/lcPSRzav9W1rKyH0o5ktWraKbiLbSSTfg7M4CoLCDk3z0WsU62HTwcG8WjMy9Ee+dBbGQdEruY9BfCuNod3rVRowmvnl9ak41NS/ThKFN8PJRK3VMIk+NGfPKk4gh0osLMozOVXMxC5GCKutAXphnk8JuiZ7CP0AHzCN0mRSLyWK2D/qpVoMlQMjHVNXtv54cdJJC08J/IzdpqEhofWhNzSxHAgK9jrbnAo/9wx8AHsFc0ZMX/YDOtBjdCWEfag9efrT6mwlErL8N8nVcnrRLZ0wJUolKsZhHGVegUAkoCQ3oCdn0+XHdR+QoIDM/Xftb2D2lNogLRdoIGQI22NBqXqGj4nmaxe6CikZipUiB83M0XIhQaVoOxXhE7pKv5oEmA2Xcx94YJbqLHmVspcF4PAnxpBle0JWsx9UbQJw4TVoJpukd/TpvS82uGXANYBJspQ/aO23Bsn2jKE2e47y2OB9doPyYVZwgiVSvfJ2n6fl4FZoxjsA4eoZrDgPoaPIGpoIIZpmrqdKpN5EJdXVyF/N8df+JNBktgMIKaEwg7LaFRd0wIlezTOeE52rQQCMcNXt56m5LXx5IQfjkC+1Qn6gf9EjmoLPKBAglBAK+3pnlS2tPnpI8jR/hq6o+3Mor8CiyZXbtsNdheifDx/rnKGioBYFgYmqgEcHFfrMtxzSwgeEDZ3wEn0qD2qxGDW+pKlFgWr+1ZhOk9sUqL0GXeLyr5jzc/fDVVfVuFRF3Kjrr7KPbF14X5N3YNWdtUYq9xOBpXaziR6vkdfhHVyIgOix9AjgMmF7ewFBGfhc38lT0kdjUqK2BnjtDjeCayytlWSUqEMeYMIw2Nq3AJlCDUFC6gUJKl7N90jjCabBzxtgq36gOHTzefzMtxzGrDWWNlKbosTyPw1+jfPT1NwOQ+4n05+yfuE69O/Ebf5y/TAAlSOHffazTy6mxRy+dIdtqsVIkvVWZhbDsJyin10g3tmiJh4j1IZhITZSQBM3Batbbn0dyH05bZNvrqAP14AiNwRguco6JnjjcYw9lYsSZKwDqUs9lODYo4/SgasaCDVejbmZ+u14eDgNioPpix6BKx4/uxnr9RdvpMA7YP7i8vqW8Mh1Durm7XLv2m6tSchN5vY8wl45MRk56q6BMav45wNDZS/2/kDUiYY2kD8oh7yZUSkhm6486habWQuOX/Y5UqitPrKxD2C2nwZyBcflKnZ6LN/mtEJkR4iHziCRmzBby1okff47NfOrGmiloqC5sFdeBtLhbj8pHOY51KkNQocBcpIGGcDEQL9KqlDk8yOVEHQGVoa8+lX12PN94GH2FtA1PEdPwHUFgu8kU7KiBpKBuAeaBO7iVHqArA0yq0h6z1NL+n/vesUo9SuvNj+rj2iRwLWTWcAhMXdPRSHmRp5fi5UygzZo2ABN7XCrFYRbyye+aimbWrbwa+3xCbPFL6fEKWFluxU9s9A4y/YqPg/Rn0YJAOOAydH8hD24ild/4vso0W1H6x7SIxaCAQFUEUfIgSDjo+IUvCUqdoJU9xXItoSKJqjruYbz/HQsPcuTiVOn61l5hCn0qMEnJ8UHnIHSrOKqcWv78uKkwN3xKnj/z/QII2dUvS1csJB5W2ylFxwq4hkD6yP+hbUrBkI9WzGAUAD1WJZFmmfp+DHQNPeNzTGfX/HbpkLuYDmPKalMFvxQLyFS+ohjXyfadnIsnnY5/y72dAFGkHobqcSFqp2FD6bmQNHCvuCkerKIF7TRgR/ioEIQ73D0tk2i9px3Gc0EBoGqjdOmsxpZR5wLJvoSTRO53Rpz4GZTdDldhI1eejQM+eC9XBpdKRGgkB0IckUCp8Ua1j+VFWED1mHRGgR2+qTfZqxox5nngpMf1RLI0HXZQErddHODY5m/QCuBOKmSv3kNBedQaDW1dLTVUVspxut5raw4WixzY/U0VpUF5CE3nUUnb5wUjECj57Pj23cmFuEAhvXAxGB5QsFaXHsA+Q91R6ZsEFUVRiuhybUc5iIpzyPuBgE7XLmPgdo0XspSCaI/9IWUgS3/niv26CbRyQl6DLP935B6knXytR4nOvq5cNs5lWI1rbooRT/SY6J+vVyICE/PYIfuVjjakJy8dVWPxWPKQdbSKZqNkc1HjpMC/lX1sV6VV015Hi4KXK1bxgeZCwZJJE/36pZ4YX/ElpU3cSQ4kT1LiCJ3oEJIcUriyvaBitNvkXiQ7K5lix7g/GHL+S74H8HpmVUybUpIOn+vjgHXoDzhmrL8gBKgvxsNiV17iKiw6SQ+xidifTZ02X+khiVa0guEUXkJEL54AmEaXWq28jaHx/mies5ttPPwbYCxtQv3i967r3bOgT9ADP51M9LscLA/MdgtIn4O6m89yF/iHbo/1J2PGd7bEUYgHaJODpJKb9XXA8mrJxTagKHGXsSAq2YhbUvBjFvg/phGGRnEYeNP8WdBw5604oiugbNmTieahUbEz5ETpqKRMPUnbNf09P8ohztPRFy3fYiPphoB/bglFNhfcpWOhqIw6mAr4rUMH/ArDTH/qexzjARxt7oxv8jN6ls84GakYU28gIPcZ6ZESEXT0ACVrERoV0OM/mMRSsgDjp/PSojm3U4mq9wJIUiObtaqFFiBGnmFArgEXoj5gRfZTou3GI1IiSPuJWXxxgVpW2L586pz9yh/9RxeMbJVG8qmB1idIqXFuJtxL0ppqSC+61UvJ64ixqK7oAbmCNwnmfUULE45zgeomd9ENcU6QQ0CEMNBWLCU9qmz6jlD+rw40EUYs5jPCh1obrYYu5BMmrvKXrU8V8+p9+tJ6TknN7EqTa27krF9U/cN3OK1XNf5yLPnQu9AYBRHMJeZtaWLsj7Bc7SGLCrrv/d5dInRFiYq8Fpw0xytofSS7ImJMPE8Xz1eGcjN5PmSa0RW/96MZynR8vXnk7Gnm2eIeXaiDY/M8AbeiYRvqcQr7wXA+Hl3m1pan1ekrf4RxXNhQMy9FkYUicqREItynwnE5jO11pq2YzNFEjSi9Yrp+mDTDz05fpKex5tC+Wx5/mqw1jqk9LXl1/fhJrB2aJkHsObDjmpD7wvKwfbyldEkoFZTAGPEYvczcoIui6nSsMUnlp4pIjOaubh+22oFBN7FLMocv8KAf6eULFzPJsLU0zBPESzbC6f8ST6pS3Jj4HLlLz98BgMXTzTcz0JJ2Nfb9QugkjKEDt81tFvjEXQBtzUkxnfTyQ4sJ8ctjC8SrvC43TD9yNk8SxNJRCxzT47ANLIei+TQUTRrmvhr7VGx9mro1eBRpCmwyqcNLowgcAU+E1GiNIi4MXpCdJRFBuypXWFXu8FSaFR/5maDTNRpIfUr9Pr1aO8NdYnwuK9OlePXE3dqo2YWJZkAfG+3mZ0TXiHT30WpjVsXFYbaJm+geyfsaUcl9gKUTeDhgo/fT3Nmu2+ElTEkzU2hhoSdg7A2iC5QczfDN3SB+U3kM6cf1xFjx9lJxDN+p7XZ4Vy+gcDezs3WZv+g2UkVcm31wJ/v8ibsQFEB44y3SEW5hi8HkkeSf7jFfPnsvynmuuZKCo4AdfP8fGgDqSHlZ+rGOlusDp9SKRazgFBbq8x0/hKAj3gfLNfD8Muciff3i5Q7QW0bkJ4mKDu27KB5bCEgXIUiSOkGNeOI5hqy01IELNR084p0JExR81I92l3gcn7UFb7s8maxrAnh8VZr5F9mVxRNms4Dt1+Ii/+2Q001hxpGGXk9rg3iRhK57e/yLuqZr4Fme1Dh2ZR4qgtU2IrO9J7Bxsats9AOLdKmnAs0ZrRlh/TYZ+qrKkBWMbkeCeJx7RjGYhaf5YWbKKZTbp+OAmS7oaDZSnaQRNgtnH/A1mqZ8H0VPw4iDgktqZ4k2PCY/i2cN6DH6hWHukXWH/KYwt1Uv0tUOmXPdghuBr3qiX6WPl/FdWu3jvoCI4xXcCMEQ6F1nHymyUHNIK2ujCGt8eaBPwIB4Kjf9T9audwqCeAjZgv7aAPNM6iQmQUO9X0Ssa8/MuU6U7O/kJqNVLJe3cFvjzQIPTcESMjX8SryGOC2g/PFm2zrPK32GMpYi6KVbWBAvVM4FZDlPx8CN7IlNOJMQGGuvTXFQY1sgduC/xOXGwKZE06ljGFLm/sntxRlkVSiQZprudvS1jVUyjWNCSjYhaQUJ12NmHYeKHrSYylzJZtAre3Njmd9RlF81xa+seQ/8h2LK4QO81DAyUCr7pdPxQVX7Xnu5KUNArpUlmwbzAOFI/hwkJopX08+XeNpmzySNDMUZ04BEAI+mbacdQamdtErSdRghl+S3R4h+K59Ovz9uL6YcFPW/xe/9HfLOfg9fOzkuYT4HLeGB/fw7xuRBeX4v32OWeWVJJ8SuCELrap/fkydMcKPxjpLJpmn4Ys6V+7J0RU3wqGIXR5MLplBPOf1t64wTyEDKFvTIuvN6e8GsuIpnQhz0RaJpWZi82rcoDcGuNQYw7vTrJGb+GF+L+gb/pXNLhubFFGcIWgGQbhlCpLk1UOdaMFfrveVcn2Z1x4NNX7WRdXSgll33tzGQRo+DAetEthvz/R0nqNr2x28xwklE3WbZAfOhRKpTrByq6H0BsJapkHg+LtSunEn6PZj4bruoaPymIXU0JJjUzuG5dlFT1WJE9CiBR8C9ib5XlxkLkDEgtXTD/Yorq8iKjEI8ZCCUz81Qx7qZJKJSk0pXBV4NxgCd64ka2TAIk1S38nZYynqlEZUxT+4+ZR9ECtLsDdLUGV7kttyrwTFA60Vnvnbt0XXOd+azCNuU6mSUAu+V1b7daz02dA7IwwjeRwM+zyDX+aTOOw3HeY+55aJGtYiCOQCTLydqeSHzth1nr3j7n8/jEl+PxmFqP9ljMYJzA6OLkdgPo+2pROV+9GTHjNH0HBnwC6TY/ekdlk7pSmyFSTB5ffgWhcYcmUYOAhjUh0Re+lm/HK3OLb4+ObxwqxWHALJEJDgZT374Idzu9lppupuv0NZG7psKOE9zFGSUqMgf7BrrFyoP2DLedoBF8mZZfE+pDsCtthGl/w7lyYcRuguRxE5heCc9WO2PWVG3sF0r9nVkCET2p6XC42lK+VWj97d5wcaRAgW26XSFprgcMQ52UY+Gl9Q2WMz4g89aeJtj6Nr+8+zj30PHpbFXd6QZhxRq9bRYWvrIA20k1/Y4r+1IcgUIzPqMpx/P/AIJk5hppCuRpvpzeLF4GWEIB/0wtXciIM8sQKjfzL4GqhyEvcMubwqEg4gEDHnZx6SUVKuaHFQ8m+y8aiqzucgpMdasxhXPgcHvZEhCDu2RYWeB44xDr9tNUB27rltiDwcRvzdDaefph2i2z01b3mZkPCAFTVVNFvATIQnjViGF3xUDLfErUREXvRF0ShkFYLT5XjrAv+H43UFH9SWBP6ZTKuQU3EgcUstTa9zPVRUryb/xkgbXN/mWKFh2Sj/uuD4Hp/wpqr5SBVtAzt/cmiXD0wecp+ThRD6DxGUhyzupc9L47q+1TXb4oQoYpoBME4v9ifMYpsrWi1BuTFTkCjdTXVySE4IVv7qdF252ASdg+KHrojjXCpG2w6lOIdXZTK/NOtpYsBdEoEtp/ylTDb80POOla9HOmd/tI2inxPdOP598VMN6Ro2+9+P52768OSQaJRjkQmVSYTLMMevXB6LjKwpNqaNOUG/21f3wqzj5mG70Ij0d5H9O51XLAVgqD8lBupnEtd6YDJS+QqPpp/sVoIYJoHviFwMKHzK5LYYCc+UwF+cE7EjQQ8MKmq6DUdytkVqf9vqmOOE+LotJDcfGRIaxufeRyJoc5V127Efie3izn2vSuxQz9iiUtEs0lDtFEWyd0flslHI+Z408JV9KnQfX565xUqF+MtzKowjsSphYNbaVTCIahpySyImLw5nw3t5PB8WSesJVfJUngFuPw+F2Z12ox/cXRcKAD/DX9AWoGiM/qkmJ79HJ4uCMbutCumNW2eec4iqOCPEN9zH8Io+6KyD5JAkGbSbWZDdvLI75fwFyBeCWok1VugRSltq+rytet/xr5k2cNyYpxaMZX/M4sumDP4mGLQRB0heA1uCgEZ2mokWJjgcZxHwk6eVfT8C1U7IvEBKEj1V00BpAkcx2X/Cs/e7TLAPyGIFNoWyoUz9b+7e6YS35bfmFoS9pA44BW2Ix+LOi2O09duC9ZfIYvfH9QH3SlSjvXpYJYdsG2xzJyZFuLcG5chvMntcRRXDWyG6SwBjsVGLTTvA7++mzOtf6yWczdOb9p4PQazaZ6HcPlnI2ols7+17/m0wd1rP5E0Wn8Hm5nfoy0urMz/3h4ADWqNOa7F15uNeXTJgbiuWnNXTx4by1DMOfHNdKQ4xnlu0bB+3AH6+4vd7vhrUe7ZrNIp3qC5L8NvC/HikubtGk97rnePCsAowwIv5a+CzsSYEjju7LHAU5JzSWPABVobp9KNkcXw+qOvD77tb5/q6MtyKaumaZUrnihhvHxyI6NSgjLpiAs50FCProUorUgQiK4HSCoJqaAl1x6AQ4MaRHhU72sDSxv3aDl0g/MHIH3r1sG/UMZ2AfoQVA4Xulh96qplEvM7Ryst10URwagDs+lgLfMBwL0KR3dJTsCDBIv9S9Z4GMkh68oRlj/bh/I+yDlyeyBuXmmskxoB79vKjOSO90UJNEug5rUiiJWoluLxuJ3JbOc+XFXxByXlz+1qXvEdIzsEzAYuEQ+l1BCAfcKNekwu3dW+5c2VD4aOzxxtBCwOMKPfr2OiWa2WwEW1rAEx3hRmlxiJwpNRvSBYLwHbVd5jXxJinMOOm8/FMBgkQUt4SShevkBWL+LTUfdDmdl5vZqpN1qVwNTZJ7VmepF+JDER4yWbNcOx2hUi1U3iHSkNrgZlg2Hh8Gq6b/TbFB+JYYA9w7qmkJXxwSqWrkmSbG/brMFbqSY6WlnobgjzVHfvFCy4rNQ9eW2fH8xP8faTldCcIxDbu/2aLWDvny2b7MpsXmhtHgFqB1QpN3raDj/VXSnC2ea7lyHsWJW1vZlRrYtLywAb2B62Dqzv59Hoa2VIg1+8FjlWNlqjpS/IgpUzm6KNqH2oYuHi/d1Aq7wypMuNxpgKgh9ZvM4TtigmZKviYlyn+YXm5PcaDduROSZs/HzT9JHNbrlPEMXgzZjPeHzUPH4bpoNC223lYmhG+2rAZbrWZBuImGynqx/ed9OvsGSQgMObvPgH2xUgUyL6oUdLuIRuUpPqQI3V9R5rfW4uFRVx7zfksofJ1N+OvEAH5vTchDjA9Nkp/T0/e9pP2BaPc+jvjfTw7kUNSlMQvIY0oA05e9OVuI4rtudIUcSJXXpBCfCjCyZHDwX2oLqaYC7xwA39r8mF19vEpwxZlMQGjKICo3683qVHGMo+EA6fwXpg1SWhClcunj22BwSGvpAWjOdZ+vKjHI/tJAPOP7rvgr4ZN/ZX5Xtv5BOshVl4APsD53q1d0lLmYizqyq2JrApidH8zy40WkapRvv4M+nFSHQLLijGUSP6DSFvybRKKd8Z1j0+txdfcClddjO7+znKKEUfGvQo0T2Nxtz9Sret/2cfKPe1yTclXX+TyIGfIDbnFbDen34Ck3FWNE47vnNYEp00VbCaAE+bzH6R5bFmGBWI4tm0BP0D+s+2pvDJkndHkfwPhYsDR9XRfcIma13puxHT1aaZSDtAHZQBp2l46F+NSYvGxRaB55UAXvVjsRYRJnHBDivlnYbc0gYWDwQNpmhNb92THuT3RyhHTvknywCuY+SPb253oFdX/TX6Ws32RK8EiVuar9fgICAgICAgIDzfb9YJ/D6NDF8hP8/7ku+37HL863ft+zJ/b9WBr6i79v10f7fsJv23Dz/B9Vrfb9IXj85e+z7Xq+37G387Lvt+zkvt+th0fIw/h9cRfb9iH+27+H9v08X7ffwyfCn+z7Fj9v1d351X+3606+n9NFr51X7fqMb6vqpP1WOyDYz9Eo1JDINCJU9wKKqFRVqBSx5edtBhc8Le5wj3a9+/GlNGuHuaETi2xHy0wfuAx5Q97kAtqJENCwFPovKY6VQ/bnsvF1ow5lEH4AiRy78lk/vbFXTcORxYUGmpHz8gl4z93FMwKhLwPVwZwa8ZrVU9vNVCIDr4QH0vb6MjdooB+YF5v0d8NjmkBiMkWGYGvRiFmDfDxCM9et5Dcyh1Zs6WCc43QELLxSqDLQPh3pu+AlX9AebuCn6ewpA8bfkcizNwwv8R/mLakmL2wrUzTAmOZCn6MN2H792s9x9W2MrQIdHRNRzXVNrLyynkCevUfEnrB6KTYwHBkM7SbT2dDtf7+saV9R2Hw8vnP8s/toJBEhEfbAdK5AMbLRpz735o8CAZZS4NSxtoOsYFEBqhgdiM5fvOIM7P144lJqDkPwDqaiARiHNbUGry+mjV/fbvBSNB/dlqJFmu+D9mGf7/vvtZfjnTh90cB938JzXMr32KDaKoWF6ZqIuG0OW0ds/qd8JX8tH9BCuOkPO7DpD1eSW1hZ/ViHN3PCzI0dNLdKW77rIysPl+O15izWBHEyZ/kywjUYEwYXgsgC05B5460zKQXvuFuhLsIWzFgynWbTq9UbOYe7B9qW/HW62dg8DVu84lhVusnRUyV1YlDe8IRHdlRzpStdL7KYv5yvO3jcLtHa+CsH2GRH72ODhH3lp5BnjhqXnNcoOYSfw7plkILOgfxv07tn9Q3teFYDXow+EFowsjnpFbgRJzEBggVQzvP7GauALAqPR8gc+8UarXz32/ktbYFn9VPBazyoiJcxt64FTm50/sw6Fv9rjBF/TWMp51hI//kTmbfFwKqVGWXD77mlURYOS7SzGc1A0t92ssUaDjmu8eATWdHOp+5ckfYwV9bDWMTV9gXt/7gzLyjD9+u/GPIHYWaUPRFPXsZvQn5Zbcwg0lGpTNXKJJ2DKpbgyaledFQxqDumnivyL9jH/DiAfzYEwjU8r7Rdx2exGUbyegbOiX8OgbQITWaBm3Mn70A5sK/p76t0Axl2poP6t69kxmJDfof8k37frTm4hKRpgSBhlvNDKMYNZaTg7f8iJbuqicPptLidFAJ7p/jNnZmPl/rKQM0/hEM1km1PYToYKrst49SCag7+WsrC0wR5LH4XI4MXuaL6qpnECnAO710MS5hXGdxn+40xVex1Ea9SMssN5qHcn40nxh7hi2GlV+To6uGJiI2NxzGT7UjTcrnZYq9ScKVb5g+xGIk8MSGZHfRy4/VZ0db5avOhdN3axvsr5rfgE5NrCUQ8YAjP2FaOvHQSBfHiSx3op1fOOX8PJcH9ZdQhOpcxQvWfsWutI8kLIwEltS5bh3I7V4jPIaS9RNjoJ8mPFYkitb30HXxcv9EcgCZUpduwNG1s9mjnrr/quPzvdlXZFSdrQvd7HVmLnUmElGDkVMEZ0AJl1fTwdCji22QmzcIxOp3C8AiXN97dGbsrPXYf4qmAQOfzRwvYjOYJ7AFrb1cab4MzpGzVR/S8/3rwNDcdVkQk3p2FXJCYFDpBqQphTbwMkt74nRLh/hTHrn8Vq7yQPGKbVh8DNf/qv4iCorzsWKbPOgxm1iD2/LYoMYyt7HstRDL/9iiOQsn2kJAomONYxHb6wVAz7OBVl6S4YQFST/kOn3ryuAGdOiIjHhKa12DxbTGCr8MWZEnLvIrVwNxY3l/rlRFjn/nUOvJ2ENlLZkc558uD3h/aw6/lxbv1MHd8EKCJYKBxCdyM0hJK8vqzH/NvQJ2udznMImlicH/6EoMMzIqLcY1FnJoBcxJsGywrLymAnSx8b7PEsaUAuwWkHluUui7UDR0+NQ2y54ghKYXDp5MqXCPXPeKnTj+cc2Wb5msuS9Dwd92xoqyn/Jam64K+OsWcdOmMSYhMJ3WRZRvqmpQGpXU3/MmX9pW1rescYNlRnLcli6V69WyFJW/7fHtIOlbfFcpG1nlPNdfGXfy+I/f4ZiHpf8aAuwJmuXUwED4zevJ2SYV+nrviKtCLN8367pAPwOwVA62alV7GX1c4R4XpcmCrvXe3svTh9/AMqWpPgi1ZTo9rgdfbqNyVdYk4S5+iSXnLOf3cPapU9+4pPv0kzB+pwCNJJzA+1J+d7w5kvwk3cwRlxuayi+z2ZQyAKwEFvOzkfYkyZ59qNLWr0L9FfhVlP6qC8c9Xv99Mx7I8H0t2HyL2IuNJaCZid/RM/nfiThih+4fqPnpWpICbNU+gLkT4GYE+z2shF0PPkbn9mQNwj6MSNHdpI2ZHN93apOItFn15Xw94fS3xjd564lVofJH8RJ35c9nQ+MZKv6+eRGjoRj64g5MTkPJh4qO/dLf1Hw5RbdHAHz1OSAtbjWZ8rXiwfOU1SW4FtNLyrV7x7omg+pwtzogzKHgdZeMR5jzGq1/CrSCxCTRZkQyMNLxp0SERvpBwaTnWULBOyYmIo9tVJ4nJRQERAOzSF17FY0GQUKT6ZrYo4RRw8jbOJZIiWp2eYtTlhF6Zs54Y5N6hL3NEncSLRMq9NkiA+ZPDrj/Nj/nDIVK6od75pa8MN624YwS26f974xAQMAYjSnJ0PSF02S2jrSWec02YCxhbdWKUFJyorswUeOiQsC1AJjCn4HugAF1l8DCEGX188z8kbFMf/gptEZ5M4gnFkGlhNHTCBa4iRBVtZ8PzN/xeDpKAHw2YqFhGR3r/s7hpl1hyeJyXBJfoISXMI4jE5QMpNqGzPgwAhw20RpHy89LmdOR89WlcPFdOdL+xX0sCaKwnjpTDBVe7s9wtptI5+ZN9QTwZ5osV8ftp+1DLGGP+GXOgi2DTPWBIZKl/f6/EPJkeSr97r5E2xJEysF5HmZ2e0b1EtT3XSYYqgoK5XEcQv8yoj0kg6NrDq1kvdpN/NLA/VTgZv0u/gRnbKqp9tvcqBCqROaNq2LCiB/KfKURxdA6dgASNDKw9E3TVuHkZoJ0ByrUfNSQpgjZHq1RSOcpzeYiPMQHmwt1RgiNtsegpbZPNpoqUZlqv6oCbyTOUdJj/mLbsMgF7G+1nk/w+5K6ysW5UpbYWyP10fWQ2EybIgQfiL/0i1aWeAWewWv4T8Tb3o7ct2qmDQWT6JTqu0EP8SDrKE1sDmuvSb/D7TaoKaqzyPKCZ5nEj4sxNXt9KJRtGOWzAsd9bLMLQeavE2uQY6xjECzizYsjGhvwd0pWzZ6CWablqOMUYLJWbGnAkat5tfhhv1GrXAVMHtNW3ZZ1Qzt43XWTo3Gjza1EIrYUQMp0R9bsMH0V2+7jX8GcbVTIsY/I8Nwy5heeDKNqZ54/nJCh1pbB/UI/GMrreSKzgPmy2plZBSR8+/n08M3+p/tJtx0jQEoSLCjz+u92La/P8x1nDDfiog68UjfsPauNhhukAF539xMVVOHT3LLHV5K4o1rInq137sKM7vCgcQvf9n3ruVOJoM620EHMZLDuIJCDBsR+a6WwCsUcw22SvyT0LVfUznaKoKHnfWm5cN0+P/EcrpbFvgcVotJCTxp9lsJ/VETdVNXXXpvna9ki2DPSZLuG7N3pOn908WZJqhShd3I/MAESzqubbTf/BM+BF3MN5sk38PuGH1zHWSmi2f3p9cAcL6p4M+SaaNryJdvohZoY+bis7Cmbnb5yir1GbqF0OzQZCCFaB1tKoxtC+4qU564RzaO8A7H1XnhiyUKp8hTMF6RTiCGb7ITU67oiBp0IdlIyVPN/axEtVewt6tA14CKAz9xMW6zfz12oatxEeOPfQn+GeOZpikDr4MUJ8vTx99P/g0ublJxifLfC64Cf0+Ncp3Zce50yC17Pmchm5sgl5AAoiTe2ExzitO4q6EAa0YzORLrifdA/q33VTjyYi/U+WtSCdkwbmWGCY108L8rCVZU9YNgXo3y2Lm/UHnFHVR5AuiCUv1WVnc2jSh5ZqWHevQpLiAIsji2pMXffq1XVjYsKcUPPqODY7aRmxqnFFVR393ZoJ/cngXZohkVqeHdEnr7qxLuv7qFiNZaxwb0s2JWJU6atsbZQBikaJkKZjK4zRoqS67u15ZzuLJMbcNjfl42/vN0VIP6PPUBsO06NTJMSO34623w3vGJUN79n+jQQ347y75X/qsiIkVBtUlJxs1wFzk3FN1WLiyaRZe7Bk/HUjXitxOXa8C4cME32ZMRNWdHk0SfGBWPIkfiCKIdkfUFbpzckSlR1HmQIv/CypWAHAcOzi1eBApoTgFCJQg02gg0FVRqOQzCySpqJgKpEAHpNvuDshFqSVcr4FDsv9r/vhocH0LEmYgIisbn/OsNfKFAACgcmbTpd+hl7EvUmkUiI0CpddcLPf9DtIydNBF86RUH/0fJBf1A7QHNT2YP28vkirLC6/h+HeKU9Yx1rE8YXFEF+laclQHU0UQtvwMW9RDeLdOPZMYfh9ODy4xnCvGbr65n3uTMHxFrq8aIcLx3ouyyhl3LZIHdG6O1E4zjlkkAsOSA+7MPhr7vUWUabJKFVjerYONCQDD+SV63NkQT9exKS6I7NXAVbEAH3gPtVLLEDTOdye6trzGAlWH3NpF6gL4rJmlQjfZlWLfKy8QyDADpf8ZiOY9Z0gL1x7SYH91qAOgVnC+/Ov+1cMBaxtTGo1fT1nW2ZagGtBhLOGViR2Bful7rbM77p6A72VNdpRymraP9h2GPxREYrLumreAxJ9BUh23Mr3J0aVBODeJRcU1at86WrKDLyQRZ7ZgxLL3p1nsLOoYvCzdoBhGlRbXwJQVCPyqMXq+Ha8+RUL6YbDtUpBbDDwUqEYI1ks/ddV910A7oFFKJuvY3BKXEA/1QWicGH+B2Jf8hKcCNnfT2z8LCfH1DvEg7j4YJWoKWM/jFjPwVx4T0t3hGOaxAqzK/c42QvmDWVUQLp5Y0YcgkYg5LX5p5xGYdliW3mJ/u2P5qo+8i9ikLLJk2pgbxTL0AuwnWDMk+6KZZ0oLW6VsvWuEifbrKhW/FnAFiXIyzv96nE9qyqzVoRIwH81DADho91spFunC1k39ntwbu376H1S6VjjWpGbwtX2YENJzdBMFz5UvDPalj0sd8U1lR74C/uLxGdcQt4K9FT5LlggfniX6WKg0nPLDvS8Q0WgNtsDvQtS+KiD226Q88NfDLy5hxMx4pIfVwnvn5hV6CKP3bCzapQ/15GJOEpBGs/uatw6WL72jbahT8tXhq2o+or1gSfzEvTr821i0Mt0TapnFZq3ItaDSQLD0/22TdmSTrmPVDQ+yr2pKfLKDQYwibt17xPOgoZGEz7ocM5Ydd9CHpgHwH39Rt86u5noz912X7ahkyTc6mEAW21PeKqkU59HVeA0sX3FEBbhJyIwJ2JJfQK5h42pUnS8MiPEJOrQBKnvy8HaF4ChjW9IWEzND28DrDRdvxsxbcTsYBJsUmzfVf6x/nYhHPfbVQIR/YqaOI5KhmT3G0RaiJYqzO/8K7KmLUPeXVI/+UP7OPea6OXj3Mut/GRkyFd3F9O0AL77HyyIbiYogdCowiHvmibdJYXTeaWgAtH5YgopC6GbILLj/TNTVsCn8ojwhKJ4JpFT2r7EMNb57QQyhMKUY+oNkfnsAqEDE7SEtK/qyczvX+ZyhkOzRzeKW0y5aPz016R30U0uYywWovBFzK16JNMqMGW7DmqzkEv0Oa5/pSpIg8QMAXx6lp/iwFv2oGTE2Ji8WeDA4KO3o/ANwEx6m8toeLeN6agHq/euykkYyR8ou0rRWf8ioM0eu60U1qM6SkwhPTrYxV3DJ++Yf9Mr+h7ZZeujTMYMhayvlSQIOZ2BESbCMko1C4kAWf7YDIQG0oPOLMtcSSlbFKRUPc6/kktf2ay+rDeddOYnpBjt+s0c29K46DEz3VQBFMSzKZhpDjUx17YTSt0LR6MTryBS921uEsHXxW4bf/W8kB6fRF/q8SsjlgcKXNmC424xgF5O1Eq/BzhnDdWG97zGEQT8tOuhLs+XCtCIIWNIwUOyksvN29teiZlV5kd+CGpTO1a3artuBjinAiDxX1iQ0l0ttM/WbuhWGsdkCqLdldjkzIRU/w6rwGtcDnV0C/C54/LWrzF0A3QMqMc0nGY0Ud3BP7DGQjF6OXWxVVDAyaMGDWkE3MqsYXvYwSGT4V2hW8t6iTtPU99yDtGo9uXwGWVjTk87JEnh1C4bdgbUMLmweFB2hldo51EINs+sbknFLqN1oQpRlJNvVSIO7HZmFXGWuVSzZLA3WP22YheU3C0iliJ3PNhiczvwEMcT+4sRhMC76sEs/TYH5VpUpEUiRvfYfkiaZXjtwgXWqzT6mbr14RzPGuE7Ssk/k2rMCdhj3DlA41Z3jB0Qt3YrNVIuh07h44voX3TXoSoScXFXMxjDVp2qfflsGbbov6YsevvVcnArxXA1jpwLg31xkWnhLOLJz9lGS6YJshlyHxR93H6SVD1bbx5LiNd5p2zi/gbZcylXJr+N3V9QO1SI+V9/hRGQg3dYvkFBSX3GWakF1LebG1o1tkkNgzhHA54ISfYOKyXFNAKrWqeqDZ3Rzoufrc+QPmxy4l230Zzhh3ugwwqU8nyz02RUuopV93c9qYyHeMCxe2iiUuj3hu2wb9qobrtdIFsRm5ipRsdYKGwwXmeH7+6OHBxWqJTqCGyr9t8UcTEsf9nitk6yKbcn6iJjZWrNysbKkFAB3qNmabcFWoNlLEwYLERnGwJ12MOhnUn5XN9A80DSc3NVMZ4JnHENH2GJ0dMIUZCBx7hhKR9TKYch0/sSOPbl4v2wY1j2kPmq9th2eM5LXg5shM3Zi3AbYcu2pwx4ypgWZc+m5x36iARXCrw3mj7hsLL2novcqbYKZchmvKWlwWY7rH0u+YDLobObFE/0jLeWo+a2+sMek41AqVWOB50xjzRlToR0XtbrL0zuHxXzSpsAVoKMxJITs5065CrIPDHyn+Dns3Sd7kJPdI/gfWSf1aDeEFRmVQXBD3XCuECv47/VCs3eHqxMhot4AHeMJSMQT8sqFjkorwlG3cmZSQUbxBk2IQQGXzMJLc4s/EbyNVKXPBoeDTDgn1eUUJTA5Oq8+chf0jdLnLxxHdmI4IkyPP5pCU37hmRNkxm34rt+PYtLE0+Rpxbjlm3QPBwMkY84rsYXVdgHHTyAXxrmZXxb7BDEqwKZB9PKBWu1ijdLCkvp5j3HqNzTc2gyCMnWVR9G5fSW4Bmv3nHmSbgDdX0KvesHHFUoybTO+957NdBpjBoznCQBJ9LKxZtjOk1JILcm2LWPN/bZjS4Bb7iIX/xLG9kHiiipKPEf477tamEuUinZMxfFWMwJ11x0Q30TQW/dFeSd8rjfEaPc+eu4YHTpqIp2c3HoGOoXOSead3sW5+j2IscasaIrahcyN0Gn0CS5G+Slv1J7XiVCfpMcqGueq1KnvoIRah36R1vliT4Cv3MH27Iqjf/LD59oRADlFgWQ3mmJQ3TkorKOhDNeHwWHbA4xVEZE8VOjx9r7arts9nsyHdGeY9PkvylLGV5vcfxLI206gOXBLk9zoiPdpCG9hr+CSKx9vdNEllHGNF5TFRVS/RAC2/05niGT3AY7RBEL9395cYVhkWrFrEUpk4duchjscdMJSaoR8o6c1XsTiUt4chvdkvV2Ximy3eK8P/L28Rrp+76zazGSBdbg4ARiHAJrUZB6CSYRXBYN1S/E2gxUKJRdK2SMA87UAsQZJq0wEiE8sxigiks5+wB6KRTAbvcNKHBYBY+wQ2fbB9vkl1vX4pDjaiFEFAIAJx+xk25Lw7R7r3rXrYGIWdinb+UJse0Vvop1k2awCmmqlknQQjT1LfKEleDpzvlD6mx1Ahzz5+LkUGopAohuY2NqESn+Du1PXrxT1/YuLoff7hKtLnfhDghcCDa8a7FKTRhkUxqdPnKo/1tsFoDQbHrRm1/rkgwry6zAYiWjfgBFtEiul/xJn05H0OX/r7CFMvtlX4df3tSg3lKk4ecOQW24D4aU4EkOt5pOL1Wh70ANIeP4fzo9hE+DdaZXToLdHPIWBcUMIRNAOGo7H7aDS2F68v5SAvO/pF5dcOw+hA5s/tIu/HBoVoBeXDs4lcCUnqX+cceLjNuI+KuW/2WaA2gJsdKiFsjTsx+I10A9dRxzL0h+BHaqcyLf7ERGS4RoMS5pBrymyLAYYud++NP01O+GeLEUqbJg/wnNbuQ8BkTDCsMm6YXW9nbr3HEwxw767/1zS+s6EFUaUgXbp3dSMTi95jE/FH7wH/Q1zwq9rydL7mDwMKPORJ1wsPpkOS+aIXpu9MUpDlIF9ReqzDnk977NXQzauCJWNPCqmmv3e4eNpcNS4vkNRHh3eF7zQxyWDMq3BfhZ5XEcx30F5f+1B+8vISx0Y1XTFHFpmqjaz4vX+N++dp3cpVvAP2/QtpmihGLkV+RZMvPxPdnKNFBjXyqJrmWLr7T0wOdKYwlKSU5emCQqgSJeQIn5Q8zOxBXRajxXe7e9LDQ5e8jjPivKP3WSXESe5yR46MOJ6mfFvb66KRdE5OzcrfT9fKYxK9fVw8a2AWRIE+b5ZvxBZHEYUKz0uiSvwELubp15/CrG6mfRDzMMeLzd8q5ViZaeMsBFcTO7T2h9924MvOvx8juNebU66DyXgS7fZF4P86pEZceVDkzaxTFbfF44NhRAhVw+RhmJ1A+z10Hli7OoKDpycZYV83HC40nUFOdaIppmE2q3chnA0xuccZBwHqBD/Wb5fTu7M9Iko14mj8od5RRa6Cj5MlQItv+JhVVqDqNDj8orQ3YUb5SS8H1h/E+p3y1cB5LhHB4R/f5L4wP32uKsUmnQTgoBvg++I4jWsOulyvxcF1nD3ZIe3m36sVL2vMKbN/byXJ4NgYdbpv6XVlXl18VgKuEUkknEAdmdN9CPS9N20eSOfKCz6JH7rUkJrkRctFvijQxkhz7d4zVWXpMYkLIe3xl+f7zkJlbjs0OTMbGBIvYLvH5yIJs8lpBiXKdoeGfdAARxISmXTpmqWbnFOdAwVRCE4L1a4QVfMDDIWV8W+P32/kJBaYSo5yuYpD9A12zlWnT/YsjpCIRzm6EYGyJj7YeIM8iBmX2bjdPfyYgDQl9hmUac3EPxjvZT7TTEDrVZZ2gzdil/T5snBcckbBKBEb3agdw29Ll/UWZ0CxZdLZSZ6tLjYzXDYyg38C7Ogy0xmTIJNZtjO1Nd6QbLJqvuHdiAFzm7/QbhnhQBkNrgEvQMUdbso+9ZjJJI51AHxqI7PhP7pLdMPxqNhzptFNfluEmkpAZ/aH4aKN0syA/8B7gap9KsgyeW2g4qLQ8fBdrSFsULNurIvchIkdNvn0qedbMoBni9qEwcONww6+WpNwCaAHNGOgJDH6Lfeiiqnsv5FAvsmdTSonY+tMkG4J63bZUz1HA6CPNH1kPHG5svzPhFvH7CIKVruoYjETLVnX2dEN2W0dPb/fm0pKRBNaM/m7b3EJUERd10V2nLKsFyfT0OVZSO49R79mETVhETjRzcQdIWRuTmNi4NjNb5vBhde2fYsLoEv9xkN1lL3lcQZGhE9cxwECsc35MRxHnX56kfbGfhLyBAbk/RZIoPHqfMNXkWD5rOHstWTq3cYRoryFZ/aDlXUr2Ixp8hBXHdWuFy74565u+F/DlsiZqNdy4O5JzDdWItf7T6B4asivv8yeGiPtjnbv9uUe1E2L4ccFtU1tvdrxMLJEZ8XJ6iUWHCbxfQw9t3SKWHoWbWYulfVCCJyHaHjeHdxAgdP/Ffn69nAm8YDZx+rPYekSuOelI15VXRw5hoCI2oeib8bB9pX6X/Pj9dJMbnvWSLkQt8DDGphxks+wb3Nxo2OsGMRuN77A8G2nv+AMVu689S3/Eu4Cne37GvYczX17Va3vwqJTIqcsw6XTkQfztJk9fzcG/CdMbwkWveDI29skIzPrTQCVd7OdFnm3bLXwm/Jslp+uNJxoOMB2ajN3ARa4t/amZyy5G+M/Z4kABHMWJd9OVG//ym+PYlEm3zCArhj/dx3xJh1yQrNVQ1+cGBo8xZEJA9QJFkhDp9qW2l26pC00ksKvnuiwpNNggV5q70mDJx2im1AWPekSVMr/t0slvlGA3wgj5oRVKCHxsrI1fqkJwIfs8IS/mPS94sUq4f5DhIfAETwp8jobKFokFBMQxcfwpW8xsUs3S7e+d0rUWZ2CxyhydyZ41OHTbcpr/0Lw/FWEFJLnsAWnPW+1qBOKThKtHXW76FavgbrPq35YKkR5rFnepn37Cje+goSAqWN2hyhIM5SjokRnTWMRX7XEsamlNTSYZLBtLyAbzATWtXLbpPx5REdG6jlNJMmdNCDRSGKo1UBv69WjstEORKJ1fFYXRiYM3Spels7rQ8tCtK1CaSnXqC4yHo3y6I6mpeo8B2WpkQ5ZfqTubggbh8YWQrjzxn+Pj2FDC5QHkkFlw6desfNqdfyTBtGEENY2Y5/f1O1y5OL2YOPXZMSn3LLAsiNm4zEMhGS38JtiHJgno5mSyHm4BIkoh1OoDAwfULNKldWvrre278fdD3e4GyGZTrqpEnQkxA3Jaj5ekGl0XifUWBFul4QIcjwbZH3X9fRjtqJaQi6bBLxAQtUkix3mph0lHFqMxe7LZ6VYwHEL1HiXF8RPtF9IvwvSfZrx4ZCBFD5tLWT4YhtdhMszcK5VeudJ3wFWk2wv2KMtqUhA77ENpkbEhgYKyIuVL4ZvTz7iBIPhDgpW20aIRTjCsDNIiZp0tUg6AUjREX1GY5M3VQZ5HSRuvd2s/JOJfwn7fIm9UvLWhMGdAYalmLAIgxqm73/HcZbWCZq/d7F1ti7ZeqzsrkkV+rgj5v2nL877PNQUZwm3xt8J1miYiqHJIW4QtNIq04MWO9FV9fr4HE0Qze7vSCbj7Y4z3ovj4pZnD2RUEcaiYNyexYQw2wKZ0nxsky93Y59YLIDEbCWdzyqcqWZV4bsInWZcSTnM1+kkToWBbMgw3hSi/lqXyZUBKdoW22GSJ1B5j5ANRti2kJM6YbUlAmOpvGhMsMOEpR+KqhDYjOC8TWMm9/OOUDbvbw0fL7FDsu74SW8eaqZwD10rJfuwcBfXGzYFNQFZcHfbqhx34zym3vJaTSu1ndG7uTX0wT5uAMkWD3wfXloAQ9z8jzVkVbhUFKPWssgXerBwT44c1IfZd67hv7H5rF0i3RSDdpCLFWOHvS9+nA23jT6sGA2AgM1IAWw6EsYyDmYZtzn9rW+ywiub1nwlPyFP53vyJ8lIwEu/0Ig1oPExgqnU59L3LJNJdh6yvLaw5NTSsP7GUxRO2G9z8NfRDvPvUs6rTRV++45i+YxiIGYJU8cixIxeQwJ0NCRwpa/yp0w+pzG0gfFnvpG7ncbpEbO6/M8Blh+vr2THtNzNs2pA60CQ6qhvhL0qe3VKEfTZM83lwbiXOf0jmpJXqNX46zTVoE2Fm7cPH+t1jWkmL2RXB3MkdukUzK7cOgkZz8MqeT0ISw+tc6z9Ptbo5wUuXlbpgxqhqZWJc4qzab8njUG1C5CbgWVD+hlsUVZQiUDZ9QXyJmA9JiLg3V0Kn4f6YWDHfDXNDvyRmPxQx/gmjSjGsdMoER0S58CqKMELLrjwg4xGO5FSd8rM8jy5D9iX2gafh8mr45HDbYslGdF6wu11/hE2KD0Co4fm7B2+9CwmsWZ1x6RQfOmKc6s8nBCWqydOoeHDU4p+QXDAT5pMPU9MIDReVUqOBFKj4XtiDbXCEFsNkWCTsAClTcMD+kG+Qi+kxw2ywlJe8ePgSiu/0uVjhCIPIR4apldzl2utCIOPbb4DQGz6wAduPkAsl/iJ2fQyEgiEGNBbnEZOmduCVJixsDZTmfD8nucMJd4h9ouhhKAfQX2K6L+VU7lBKBbA8N1yu6wZRnfntUl4hOcsCF99BRYVtoMN67tTTYX4fJMQ1MmXgnb85pxfyp0tkDbQA6CuG97Feey3YdLFPaP1A72WXA9n+U/43fvhh4W5id3obIJihSA1AoPP6ZOPwpxDd3IHe/g8g50IlW9k2gprN44T+cDJvnBD6XP4LvHBw4HO6UGrw9StwvaXuUfNGS6Ogzfu54cUXMk6QB+A+4klPSU/0CWVbcqZoqsAVCHNxYQCGyskScxFE3Tm3jOzFYSnyiYI0skZ2oQ7lq/gv2WOLgEU764w9B1txh2gI7aH46RwxKQ6sJAW26hDgg1xb4LzsjxCX1uktfCyURvc0LL8Rq88nQgmE6w4c59gUtsTNZDPXfbPvjuN3N/E93kme3HJuFoF4TQZgp6339Gqm3mvCuiwTohS3CA9LmQmoKTJw5CCQ8f+zNnibTofd8t8Gdbs4L1/y04wZu2zHcBActw0XSIliMA9RbNo6onhp9e3h0dCy6RP9+uXXmatNrOj7I/TfLVWghnerbXuStR9guMQykmQbgFAufbaf1bQXcZADrD19jNdUI14DZk70luL5oZLOj1SCSmLKtKp3Pc5U8bUyP5K054ZhARn8OCVfC2lJ0XXvPKXDIxYeILo59IRzitp264+ig8MU7cjVaYUf27NhDnyJXiacCC2kIJaa+xCjutZTytp0ehoaXlhiL1DPzKZh3I/tRfyh5mBL7w7y77QysxHYr/D97Z6RTTCoDgHYGdU3wKbb4TDUqF56+8705xEFJWqpccS6wGNrURgHuCjyoV1W2kG+jllfLeyedQll37RalBH4378Ugwx6XRdeu31kXlHT4UpyGJ/24kUSGOMuKR2Q3e9Gf8srIq07iYHH4U9YPXtkFyby+N/HArWtzXxVpsR6UW6MnF4rRvrZI0WmKcFPqEGVio24oPV+gKU2chSJp2EIovFWE513hZU2/iMohYBlHjD1gD+rx9on3XJU2VpLa2f+zSR8gmnU3lSnQHPIW1agVq2LCOvyQ6R4NJFXDh/xDYjgV9l/Pq873ssQUt+9BRYkWbjIbbnXNjU9vymSUVsyT/Dy66eUr9AD0SoDYVJUW2Kc2ZviyZXUZnXWPGIsfnsh+rXh52bzv3CE69CNBCInvOMsC8cRfzyOt3Q2CgtBowGgwBeEarpQtOMj7HOjFC3yz6JMSPrCiAph9MUwBYwkl3FzluWxPiLrwVXQQfRooUa3ZC5r6iIzNYlefswJDGiIM1m5z2MvbXEWbya6EtAV/DOgJkmY6OPlRlmVNPCAxRgFtEzUhLd2u/0hC5xhzYVtXUve3EmOy4MV8IWGOlEx0KYn2696knQX8+fIWuTRVfiT/CtWd12QmTHNBwK/w5dvR+ZeyZ6SXpQliPi9+DQIBS8G/b+V0aYYenmG+P4HD7hNgyY8FtZfKoziyNBk8cnrs47W5cAFxayFk2VspBpWYRU+aEicMbC4MaqSexoXOdAwlxtfjYSdMQqnwYKM4/KemaCTpRZH2XgB4ZA8UKoWzlObpEhAC2JZev0QELJscdXfRnwAqSOao/HF3UsFjmWNRjkNWzd6uODLdqO61y2XI1guR5B8hycAsraYYAui2IgGAChiZvSOx6kKzCMIxSQwEoF/Ev+HJN1qw5wi36wmmeYXTyQv0wn80s0WMbZv+FE6xrLtTnjZ4xU2rFuIs9/RFXEQ6WabbfMPjOLgW7RQSt27Y67trADqUDBr3fsfrJkczmffuROq91wBKUuPM8hsAMxfqQVd7JMh9idltTTmtiW8hM0krgRCvxOv3xQoqkb/hAtzCNt5g3VGtejJcnbVGyBcvmmTD2WTJOqyoSKB9yTivcd9rMZ9tlYhcqjs9pkRqOMLw/WKZITX+Gy6VTj9Y5a/SiRwZHC9zYUv0fYjsd9/oqZZQwONEyKs179rU23zMfg+TKPzoc2Vn45NJwr2QGQJZnnPmBHuARf0eMttRcEnHdOEi1oX3pEtU+0ha2ibEomK2r7HyRufcL42dKmDTh66r9pmk90MbtJcVLw6R8Xttpqa39wH+DGxDOo/kXi59YC5L0gmCpckQF1AMWdtcEQdztjnmBhO1ATsvOMZ27227nN+ugHY5z14ft75z1tYkurIsQjmxvV2HtzbzEIJlWu6NtoPQFLFhmdNeD79QKZ0a5zCEp04XC3gEOGnW0D/xjhhV0WCbhOy13aFZfjjcCvEikAlBFWZ2XOr3sMFFDHFmlE/mQM7i8U1kon6M8M90Q0fXvQ0DOJz6dND6YpmYRt7CWRSVJah+Z/i2oiCu/moI93ePqOW6w6lP+AjC/QmyM06XQneOPmQStQc8GqMbRwmOyIKJNM6fsnsBwAc9M16SULSVFtvK2dteSh5DnkRiwJD9Z62A0nV7mdP3aOPTFHVAc0j9zarqRJEFzJD7h+VfiK4D+8rtdPckpyVmbbLT9acnV+G8Wl5xm6E0NkVy6ILxaS4JmLyjy5LZYJN6sWX81vgxgaFj8wkg56Dtr3Beh/HfzRTfAs58yjxvEHacMN3/86tIjB0tNeeZt1q7Y+OlFlUxl/Mf/OHun/YLJt3yC079YanDRyFYglvuP+uBCt58yO6u4ZWQh8sqJE0HciFHtTuC96jp8O4ta4umNyuBLjg0NAwAZcgyjlETsCYze4CBLm1suRNnF9yDEBCduvItA6G6Dzb6GhsfibgLtYp/zl/qXmQrfAHv6pxg3G8vmaqdCJRt4gcRkVayPjIJkPKgwS8zzyKAGxXsNFmoELVwLcCr6aJHvEY52jiYoZ+8k9zbUjDeECz4fC/vHHAtAyaLMYs7IGl6jBYtd6Tlk7y7lr+pN/w9dlTNNtRfZ749BjwgARgunM27pYP9TKI9VVVswHITZY5MsEKbcHtcjInO6x4v6DLnw2hvxacDQ1FWARrT0ojr5MGEoaKz0P8IwxZGHC7VdvYL0GVqusqKpWDOa6qFciYvpsg1Y7TozaSfff/YWq+TvovJDRWYc1zMVpyYn39Afs57/KLVq5lTqDITo+4h4IJJHrEa1yLfhqvw3MagMifh9e4ITevw69cq3D6POLzSt0u9rfZ/Kc2Tb26/g1N38cpUVQMZdHo/QKjRmfMY4/nq0MFT+SH5UGs8zLPukOmThvg1VPLw2XSEWGLQZrOdHbVseeprmUdKS/zKKHNz0ycv1kGVS3gxCukZv9TURRPKDWHjK4aqbS9DETsl4PP8nC+P6QckaPCF0Mj6WtNzQt35Xb/jTHESvjz7sDGXf6WMXdLQELMt/QwlT9G5tfhZ96JWO+bnvNNQ1DGoKf6pFYNXfCDdyrr3KcrCZQUiF+IV5/Ob/OHlLv0cfhetoAyPm8yFzIFPW2Azdl18fUzW5kd+maFJYDJHJSwFQel7hDipyq284ba7yl46Ny5b9d5C8dfCZgb8q5X15HrY1N9+oCbTuxDvBgzZ8QOd6e9AjoHLVtwSP4f9Q1iSBcqmYrI3O7KowzG0+H5eulIq7v3nSHh1epc0U0UA9l5oy5DahX7BbRYQDmQ65h/UQK3PdNMCtz273+pdkwna0Mx/wtx9oaJ1PGoMxInHdXGyB2Uk3+Kv5l1gZaf49eQsPD4aH0NVaMux7tFcEqTvmAAtLjtDeMRow7IwtlYFWIKD5Go6gJjatmdSEYpWJ1Dq9zBhDsY11fUowRl8C6Lvm3x3BZnwNPSIHPS/IolmtcghU5VdCed4Z7yuQkCnJqbBAuIwMhWRt/ZMkBmX5CVOgikbOaAmagellqBUuZwW5MAarrQjLtSAdRTl1jos/ObWeU/Fped/9gvgZhnisqkwbzlgXFcdAWYAx+bKWomj9HI3PTNe11c6/EjzqMUXzOMYqXyQelVudc38iyKNkOpLVL3YSq3+7/lpx3i7jUTXgRCXHcMs4vNztPsI9sDnqIjZKZH3na3KDSO8Bm2ROI5vzhbgeIaT9kdNgv7S0NSA6ZolfqH961y/0t/zx8vq0b2HrvOrlYqcj7ODY4rsKQUrkS+QtWa2QJhdpWeX04uiTYmNa+Ihu8OZe2GU/ulkA4zK7zw92gJSy026LIZoqJZUfSTeycyjzZN21m4+YNsnopf6UB6w7FMqRLhkEPt/sh1kCmN+ugSZlwwoRdE2+pVqNgDLv/ek/F088LjVCLsswnOQ6SBOt58hyUjGplueE3M1EleOBYE4fTqrnTVp5iPFxlDStV22mh2hIY9FiRIlodYv3a7TDjgeFbP1VVuvX9HMQvDI5U8eeNQi34iMwUf8u/0wgaT7oZrcvHmulCNrm1dEeGQxpV1O1HYNJ6TaL7BiKPTnPm5nMzLbWtAfeoZo1EyaeNe3Plcn3oLerRePLVo1Jh4/TZX3xDIhOv23A80qZU09KM/z+M/728O7lOsmGr0JQu+/sbPg3ZKqyyuiVjnjhNnXPCqm1UFdn16YAtKnvRYqVQKJMCvTOYqMygfUnwNUsisyI2b4dBQgur6xXmGm4kCehvXjyiosiAReUvvDCJdsMTy5ck+Wkn2uTapdlYMBAUeFGzsFdz2hJ2beQ/g00ek+tTlWbG3CyGeC/ZvFPWv93DcLnkR/zosLooidGq0rhAwVpm8gm3hfhzUDE74RW4VkWl2U3G+3QNe0GrJTEVyETHnFhI2+QG1xP7j8qdunEKV3pRFeVYVyG4U0wl5v/X1EOljK8KVqZPA1HZi0mgjbZIRQTtv98gau+8Lje6+/F/spz+M33MgC/8g+u+BLnJfPPhR6OQZCzo+IHGuI3TFlzDJL1JGre8JiSYoezg3ixbdTGJE+ZM7RBXVCRwnwRa8/3uowUJy6FXAvLj+E3ad8Eg7f2ZywwDoUnBzPLa5EN0q/zkKv4pQZ+zhmdoSI9SA1MuSZ/BuxzfqhZ/v6N9dzZmw33Dw3Uh1wO34/Z5k6Xq55cblFVTYMvmqAf2SHi5qfd7FfkDs64EaIBe9NWn9MZdf7FgKcyQc3JHknFqDR7zBTO2pHlTs32yXT29FbeaPZ2RDj/ECSewpNbTaenAHr1/wudUK1J3YC1vqW68dNxqN0x13fkaUq7Ly/QTKFFhkX6rnUK7D90PklpbfEY9QN5A55QbMciyoLZfmIAJsdchSV9+Iq3SfUw+ZFbdweNPf2EEOqq+rcRJIqgqmn67Y3KZQy1foDxKBJllXVXjnpNmXYjC/l2KXNorCP1HE6SXeg1HaZXDqNgM3AjzuROH3S3NqEQsDGCTuvVY5jJRgl0UbHhLyxOiTSEi658JejLeLfyAe6Y6B+sTNNYCVJOMfmPqGg2N+NsdqLrOLDkiPhlJonF7cSqkPPE5a+tWA/Bvgfb9ItloklQY7JMVVwnHQ0cPShfY8Gz8lzj2Fgk6wlPKW85V96GajplxnJ/rD0NUEfO+/If6FBqsAfxMOXFZmZp+pKyoWV9F6J148WV6SjWGX6VxxYQq+EQsLPl2V0cFvJ++d2Fa7XnUiQOxiIOp9heP8eNS+EZX3KROSJxnRwlgxTdH1f14yOaAzD1OQR+brjL/o0D5mOJBwfNyQ5ZS39oWDas+AS8ZrkkIYgYZGPyL0axODD6uXdxVM9IYHPsiii6zHRaa995gjupJxH/Ha83MhoMTY7RpZZTCw4lCBIBBrJYoF6tVW4N/WDMYNjNxAp9IRZGAJQFzgCQrxUrAPJppelgONaIEa7oVUNIBkeba55kDiBWmbYGmPhN9r+af4llfvDlf5Xwt6N8rKNh9b5bFDns8Fsm77NslB6t+xG5dB5sxQ8EoI+5qgQj3Ypi4j0m/Jl/BIjh13FSuzs4bf83HCuErjZtUlbXCBfUZWmNA1aCHlrdlHcwXu08+aN8pqIFzURqJrp5rJKfjMVa24EZ26v1J3NkUzTs9LXtvoiS8RNM/t8zPtRFgwbJC1bKZdmZCB/Y5SWEhZLPfLdY1Tyk3cdxCKeddPvqdg906VosdOh/0Z0peR/rLkxS/aRhjY179ov0kk7kE/AP/CJXsW2ZzDKch3WDrO/KodSKvI1ExVanPnjTti8jd4ryo1HFUs2K7jMOgTT1/MOWZo/mPBxT2Vzhi+uwDQPk2wKn+KYA4BHXESUQAzkiT1WKHUmQ17D4r+bwYYUNqeY6MqTYWahh6P8WqJi8r9+TA7H1avUCGHz23z9Jq/a8Y8up+AG5I3rB07Itu7JR6/gDzu+ZL0eWJwB2neHADo0obVCpQ6Ft7OSY+zS9m+V+T37mmBuQRLLRTfe4R/BUJmgqkgoZgN+pEWtvBggppT7R2MRX0Cu9K3oBW41CjP338fZRohAKcbnnbIXEAVcio0FvirHCJsVK56MSE+HrwRMOpngw31Ka+dz0tTt9T1hTcG+UtR+WcYYeZunnJ/VIU3QGQ3XgBV8tIbhOKAqYdZ+VX6SFtpslPmtb8Z1mv4tIKrObnspUIj45IkqCutSGh/iIp/KnEYya8KSk7oAgnidUzJbGV/j8kQEcqYcpXfWZmHTJLgh9Gz+ZmMGJ0CpvVBAcYWnijr+vYwYP+w1v++2Y8P5J5waqh00HWrQlwPFTJVqawQedANmLQf7tk91L5bzVq64o1xjv5Orqz1iHTxiAe/EZ7DSZTtevgXIaWpvBKKRycP3HSy/cR7Gr8km9Qiye6C+bVCq38B+5zLOb6i8gM+rXZGCFw42EMM6KFtbpVgWonDeqrZZyOZy6WafZS+0K/kewV7piWxnw3y0HSmQm8P7zq0Vs7qJcOBx/88UgTNrplOPyfZQrEwq0hVx/nTuE5yGve78HWthXkEiRxxJCXCKX/qvoWzxySXdEP1iyYbGkbmnbblO+X9z7Jh4VO9bIJUTprV92Zod+v/TshlBfaDJgpErVmz7dJUyaU3n+JW6liKdVXiNTmb1fdt6XCybe62Z/L6LUBXOqDPGMRVMynL8c5VOKN8XsBAjA260p2xHP8rsJU4BT1stU/ESMYXuFquqiakTOuZofjK+TmiLzGLdUBqFZ8FHc2FfWjsPMGcSmaV78X+zJ4orL0u2xEvFHPlsZ5alZcioJLfrZ09JS/Q11dZcvESmEqwag04U8g9rThv9BQCDGPaBeCGSOwG9EczHehreOeGGYQ5lob/yjWrOY/nOl21H7rpdwNEg46cXisJUlgdJZAXHepFLIL8nzKE3Fcx+A8t87Eg3sW7UraejTS9kcAm9aYb/leMBj4NgAtW+ZDo33KoftdTpJnQkTizA+4O4pO1BXV3idCWDx7bGohhLWv49j/zsmAuUZgb9cyVJ3WC9P12UDliRmHBphKY3VhkUK+HmXM12+KtF87+OX77TPWuNQLVXZCoYkgPiJTFgDOyff8z5F5KEUGd1wD0v1fHD+yXYloSKBzYGPcPKsSChbjAP7TSkff39NI+VjVsifFBEoCVHOiACG6DFN8b2FQd1GzWZauBgE81DuEb11jkSlqgBUY0hnzLSB8vVlTA4ff45SCmQsmSBeQCUcFBiXiZezlgH65s78Elv5Kh6pv9KycMCZpYDI/ret07CzzLnY/F84fOZnW2FUcdHmOqhqGZUs6kYLNn1Ji5fSxhZ4iHowF2cL83dY5GpFXnrI/FP1y3Cq/d0uNz1dIgQEs0qtFkZ96ZOWYfs516PLsV70bNgaeNIPzg+lBC/zeLLQYYalYVICZbRlRA9jfNHAFjzECfEQMyX5Xv5c3Ilu2hohsYB2LlyRkw3UDLpvnRzQrE2dUfEoCqQiqEvsC9R7XiHMiTL3KNjsMF9BcWIVSg/fJKLxQ86E7BnpGVn+cVMEzLgLGf86rk8cDauSdGstsAuz/Vpn5Sfjv/8QFj+ajiObqvifDdQ3OeGXkRALhNe4QJGLkUuJcNx1tKa+oXWzmSiENiBhAK7LPebs0hLoHgfQwJuIhk2fokUAA6xwUh+HOrFt7vcrEPIf4Bmisd78SvDQY3uOIjjlK6XyMGq7uz+ijA0xacVx6GLW3frJIVQAfoXLgP2ym9eIvCr/aTnRCpjMmK4d7VHC0uz+GAsYuHIKiV60M9wHekeF0UaFMGgps6SkRH8QDIjYr2ic7Z5sYoRDbAJfd4NhGxg6sm772MlfT+tHyxKLN0zJ02oG0HHzR1zZrdiQ/0Uc5IdyiomDpf093B+RdRw0TtsNztrOjwwhGy1341onUPkltLTOAyXLKt/r2TRmbukhtFXPB3Cbk0YRXeYe2qmtQ0iCSt8VwFGpCqpmCrNUWihtXggqkJ2uC6d08WfS4vQlZH4rJpNov84O+Y+RNvIlQdJ0BNMxoWTtktKQ/m/4mL24T6I6RZuOM0XM65FhRiwCutUyHYmU8nEfHS7kRdJNmPCASGzQGuY9UnmYYZjWw2IQgcafCtHO+b8vs63bT3JZT7IuZVbI0nZMJ4BQfUUrcuyyU8yl5MES9GpCdSuy7cOWRr3zZQO40yYuXWDyeIFB5JyIYYA67P3cKCo+qQzUXno/7zIMMMow7kemFbnZ3lDZY8lFz8iOPI2HedPIO5TeWn+Jl/7TG7gp94vlILRcLRB7A22Y34ufJ3cNg82gGs9F0Ms12UofiMpogjvvwAvn4hCDr7T79IZziq0kYF+dPtPVtUgwESwAHR0cbI0Du3UsPPXy1Fw3H0pC5N4Se4eNJbHsU1I0Akk2g3oVfn+RFYzeOIjX0HwiNRBjCI8FQkYgFIP/ZZ7C07cSUEV0Nj8bpRk/VxTesE7+GBp6d0G/5Xu4GxMkqmIOTrtMViKJag97idEhRWsKPI/I6QUPoGgAfQeuUVI0AyZLjD/ldsKv5CUBg9RRPsdK6MMoYwhSGibgu9cuhY+aJqpu0KLsF3IaQZQ94n0s64VdmUd7vdXHpwpm3cGnyXFyaZhq5AL6BdbFjuS2/2BF8EMUwzinp9o7hWNtMf4yB6fnv9jJt4wxYKJuDG5ZsuFM7IyoH8/U3aZnn5e+mWJ3gjNMQvOvWIfYS0qrRBVU5luaC0dW94YQVSnaVGUNUceIrDiQDPIIQDlspY7buAqwZZNbNsC2xEB5k3GedHss6jzCgOWej1HnghCReWWoc6ibJrWMtMmE05n/ZG780SClb6HegwiPRJbLbZZ0+01qI8xEKA7UMgdOzCr4y0+eY8hBfFhYYJa9bqYS2wdhfEEV6CZUvW+wHb0sNBbT2lPQcPOCxVPqE+86wtQ4IS9vrngZw7bbA1/6fTEi0T9zR86HVp90wquwjtrbY9dqgS0HY23IutRKPPvDoeykYJSLCopUZhZRaDLLj8hNUzlqT2G/ZsqX3ydFCCyqlmayPVZ4eXlwDwOTU/OrI7IlIaRhTOd2SThCE40Dk9D5kvW/2pt0v0YxKbQwqBLsRqyo1zZczcZWja5CqaccQFz7quxDnLaY/Z0HBpVx1JyUbRERIc+Koc4qjp2qCnY4FYHhiEOLvYQPmOT+dbuC2CpnVwbCCvKUhuF0x1fQnn8zNrzMF3OkclbrGu8dpaFiG7aMI5neOQgfNvU8R2bYCiZIr/7UDHwvdC+6UqOX4akzHijXzEV4QVeX+LBIrxJg0j8o1fqcDX3A1zBJySYeF4wUiIIaa43WW/Gns9qSLDCUblrdoQV3M9reK9AWwXn8e+py8EWaQhMLTiQbyv9H8KwFlSaREXMv9fquLP959KC0NSNHb9T7v05Wtq1KMehZegipduxu9xkibEP9Kl+xUmIiYyrNUrY5jlyJtPS1dwT790Hrv8/nS8l5VZ6qVtG2rB/0qtuQZ7z8qeWcKzXCF4Nmpg4Cu+WsIMYc/ibEd+CGmEGBIigI8gUy/rqXV4vEghBPi25yFVoVStUKtW2lVEdSTh4NI/9Gg33cVDPqZljeGmakQSTM1pjtQUjVXuvBRacF+U0Jrzkhw4xB9sifYQcWxm09ubYw7IUpTI4h3Gfhm6Dhsl4barRU1FnhAKCf3iJB+XQOe4xaUgU4FOUZSBTO5loosyGP93PvSZMP+hHYQ8ti3RvHfYUjT1Md3942oe4HusiL71DM7to8ueRF1Ir/BAzHFBM8w9W2SyQTzd2sRpNiufQHxhrqnZ0lOY9v6vAwM3YncQGyWvINDf9pDAZjPVn58NSD45UAQMLVcGssZ49eAMXzZZdl0cLUynLurjCAtNZDYdilu8M/NAQdJ2WfieLV6Ky9gsTit7lcQKDEyHE8iW6y1n63iIa81nqrp3gasUb8AId2fkXGZCTYH60j4dUZFqbkVE2gtk6h9i2sco8JIRHI5W5kyqhEjRfndH6dBQSaw361A2tTgxTm4Z8Nw/pVWUtu5TxxVFOgmTebKBfddAJcBWzY+dGv5xQJTmUE0slHAJPEuZDc9BzRUxvn4bGx3nStMoAI52YWsCxBG1cKQbhkPYkSHSw87Gq4pnKNdTpPfj+8GnCOUKgwrFIs3Kcj3TVNkJnxETX6kLhh3irbmvvYybptwQ3Fq1Fuqtbeaegd4daDIj84xeUH9GSlEuxKZoZmtx8LOstb1Y06Etn5H3EE2YGPJWX2AtLqQc5bGzrgWYpCpMwU5+gxk0XfNSX5Sml2NleAfcCp0dl2g+EVp8thHlvWmP8tPjJ2Hcla0OBqm5u9HqH0p8Mzno84l70eem5A8qS4Ua4cZlb0Y5LPKwTBovyVe+Qj70WfNQuIuA28EK2PgBIn5TG9EQ98Y1lqv98zLTU04K/CsGuUfVMmj6bnhDU5no/Nwg+ndJJx0sFLKSD/NPSQoi+humLFujaB+xEIY9CkfW00/edNHt7ZIo5GwsgN25J1HOMV/h0so6zQS9V1UHUOw9/fiKXNVwuhRhqFVGyLtD8z4WCTxclrwSYM1Ozojzq07Hk5yW+sr2EH2D62Yn3xyhYuMLr2N9D92PuI2ooc38dIVmNprnCSoW6V+ie3Ym68m0tQGhnSgmm7OVY7OEsTVHltZaIZo7pwQWktqboPlnaDwgvuGFBoJV2eYoXP8tbAk0OQJ4QKG1UdNMpr6dxQm1+BgFNvPtb1JodyAdv4HMOSldXEo5u/NNie5iYb1VBQblA5A1V7lheD7mpneWq90vpTrtpCaE60Q54Q3pVOLTUSAkGhNc5CVZEDFpZ3UHnM50uSD2X1+vIICv2ScyeLxsTS56dTbArlGvNayhB/ki5w5XkZYpZMgCX656ei/daoMaWL2NeZP3BZMo1IXUlO5P3oTR8C+h3RNcuZtxIUJUoeOrwiwmfVJXkExAAidE5O+5Au0rrCntGjEcHYbj/OMDL1Qbu+WaXUfJmK+O8qEfLoCPgZEiz1L3CBMlefzCeObeSli37q6ek+AvXqflxINYef8uw3nTR6CEr6H+lLe57blesq+jz3Adleo6PBqUP5NKEZtF2JNF8qFqpyWYXZqknhyHURS9nO0A4sAFN5aY8NatL1fCKMN0GcgbqFzn5nnZyYOZlvfyDUFRjejwDk+UAHOLGSd4WZM7wqG7dpNlUlMdCdL7lXZ/LHenZ+L7oVmHVDbvy12em6VHlY1odsCFTCxLLNXFGMGKz2aleWP6RU2fEgbrQ3DJHFG66PBtnBHfCj73vI8t88RMWQ4a2aSRhKM+fx9XdlDzWAtMnf9HciVJexgbLST+n3GGEVt7WAMtdk7xT8cEPdqD9tJ7FbH246DxIvWeBV4UyOxOanIL2ncOjz5qSSrt64bTtMlTKG22GSwnOeJ5ZM2RCyp7vf6AHsSuGsCk/zH5HFQig5oBKWJj667GOun2W/QDjryJ2FfgiRM8AiLRtNQ7ZBYls4QtNR1rMqAdCFsc4LnLNOqFW1depENFglCengMR62QiQ+LCvZAw0QCPpDpq/4PePsIe1Hdsnlo0Jq9HLG0lTLOC9HMi9Hb4dfvDeIVbRjTUAJkwSxSmPBj+4X1oFs4jEJJvt5DzmlmIj5VIoozQn+DidjdiDbGgYF6HR+OJGJY2zCRfCv1NPcSq/AtiIFdwHPEjud5zhf/UBBSuSfjx8Fqa7POadZZcGtW1oREKXS1lyuYHeVEky2D2v7drcS+VClvcvsM6vUELIR3Z+8Q55BtP5P+nZSg/Q20CVERkdY3A+GnKY5kAXAZfmL/FqK3JPcAtfyBK0Ta409WFTedaAtr596yp/h+z745BTzvvTaYIvyYSwZLlupkjB1M0PGJEJtFGk6IX8SickLfiXCb4BDojHeVKsjA9u0yo97wxszNsZCZ4Wwy0KxP/SvrpSpI7755x9S/DJNcNM/2lcVwAHNACYGIG3S+ZZVJo8boPEVwyElIUtAxn87FWogP8NlcsLaKm8lhDKode2wcCO7unKKJ5MPQejJ5JeiGdNk03tk/mCy/TIti2/coT+7Jbchp/NnuNnpoM8GsfLrvPAnMISh7iTgjernm4tODvH/D0kvGWYdVQanDmo2Aaiqvlx4fZaSVWVL186qEGjur/zGD6JKBU+YTWzP7VhwyBemZYM37C/HVv7ZKL/oL64KwbschjZ9onRD4pW+Dc7pGi4MIg9USvk0ugo6lIm965RGgjJ5l+5Hey9jLJRRupJKVmuLLUfnoYSGw+lUvEMQx+dT1wzg8CesTL861xbeMq/MxMjPbHKXNuwDoew9a+yX4uBRvW7lHFri1hQJQnQkIWxIAdtcnkrDewZibNWKmofrQbNezwOOFJfB8xe09jdT6+eBsiWV43+Be5X/Mkh7CGIIQt/kvz+EpHhVKb3p48sjbsVApVAmkb/6S7Et5Tfe7h7npfLZGn+3S9OBaZxXZ8o1v9ImS+SVC/cZxtGDO1Sx8xWk5I9JbKn2dFjcRd6HFsmpFvi2wun+tsCVI+F1H78GXAoRp9USwH/XWSL5KWW6rqXCF2eGdAO1s4wNEa4wDxwOr0D3FZT3g+hSjuyfceOVaH3eEwKW3zwodO6N54JMFizvzHq7aL3TYcPhCgldm/A8BSdr61QwEmsK0fpH4kCooUbfleHvdfLLY3neqaalYPhj7N2dZwQre5AOX9ts+2MI7B5aVvIpbLTJ8A2U5LZ1jpqVnHPxTUnByAQzK4saka9lYBde6QFNqf3MjqdtHyVB0JmL/QecxP9JFJavhpsalsRsSIUeEjyU5D7ineQqFcaJrU+vfgjby/LyGKstQQ5GiMiRevTP3GwlfR/qSsZYRs2As8GkVF2RMdC4Mo4KxlCs1/bISMdVAA3NmaPWT9N4y1n2BF+GLpv2kD5mW9IJEBJttRWFTvNKZnh4UiU4Fdzyu+zy1AFcoGbq4A3sBNj83gLhDWhYMSqDvSupEyGIGuoSmtYP8oNF+6m8BGt0rikmrE0LgAskS0QXBRVl8iRtOT4ggYfhTtJ0U2dR0N8PmH6nu5BuI5O4+cFpQTPNfXJXfIIMeGJZOrMksuGCvmPDX8arE/b/CscQMHKNsAsaqv95DcAmhQdDIaS8MWzpnQHnzlo80ZaNhQoVqcvfnadTAq5oi+DFBbZvlYnoP0CaqV0D3ouH5WXlHzJ1ZREH7MJIB08/1/sQO9tLEHCRstgzLwbPqtX7NZvSQ0Ol1LEvGlTVaPvT/ELOyMuZwIwjwMBwj9B/IfcdicY7CqCt4b3k5znl5FMK/PQy2KH7lntdVUd16dYp0C6H32LvwCEExspX1ZhzvzOHLsD6xqx7dLwKgv87woPDxuJ/y2RRBI2vMwl6ISrt7TPpMQIxc0n0GCmQQ2Zr0hmtEtIcs0yKqf4+W3yeSXE9+Oqv/3AfNYGKEU8uBUZK3KhkXBJOd5TEmv79pdKraLUuMDmY3HKdxxxDoMXDqscRd/4EwCRcpkDFnE10tjfm/idO8JoGJedSbVD/K5Ub3T5shnmxEv81e+Sh8F0xh+WCKdkR+aELqkWgLc/GO5dJdqMtc4FOmefq9Ddx15R7ukp/E8lpx7ss83GEAkNLGCS8/aHEgnKxOfFeD3+9bWCjl5vFnnZiFH4+CRickIL6ULC9PZgW9UZnQ/3QGd9s1zRwSAPONZPC+BSF1664ENP3uQNPijAzPDxrnb0WznomGXHMWb/mCUArm66Ro1QUxOmbGTG1pVf8FCjtNmVcZoe/a9xH2okBJ38hIu3aqRajDR79uvppE9z8nLMDJmiFQPgEHUOKZg9cqimROsB5ZxCE6Lkq7fiaJiogiXV3Vrmen6An1YgPG7AZtmKCj/sOAX5UbUfjm64j0+KJV3B7BEwt52aPRBbTsh882P91KzcrYiI9NYz2EJZPmrCc1RqLFVth48dMVzxCGoJX8y0wmrp2CLifGRPRpBbkltltXqNRyNU9vLBKdZdAy/ShoBEbDrLFCxxZOs79Hh0ehXaoG1CHXPeaUS+UuDoVTkKLJ3qOJvrEXAqBQ5pLwLIbCl72ugaedacf3fbn2IYqErTpNys9DuQOcQyEeT3xLQ1DkbddFu+YD7ztDz0Uoe/TDkxYeBdbmgktJJUzanSGlxYOriUaaoH9h4sqxcdptpDusugEUI0CyR1Zri9eHgblN4wdenWEie18BA7xNJ4hl0jXeXBKCr6bAUmiE6NAOaedngvx70Ifv0wZXvReQXvltBT5o3gwV1V1XJxfVgwmJ5rtX50VG7Ea22AZXjYv30GQJjxr5unyWHZGJVU9MSQnnE5PzJAWKXRSA0hwPdX+Zlb5M/ZjbWldzgogyoFqrkOsCZbd8/56362CtbE52Kzn61Bq0ZZq2hesRuh0+SQ4NfOfpM618JVMna4ysi7OkrnVF1Z+gsDQyVueQ2DeWEWgayug63wmMVLbZllSBkI2Hf2hqBKETJstMH3gTbrWSy0s6Wy1uoOMYCCwRQrBAxhXdQ8EnIXRlyBxuYm91g5RFDKKQN35KZlYIsJVeNpSGVkT5cVWb3/jchK5ne/PxpIXO6SsF4chPexFYjGcBjtANUlwN6Yul4Cseg2xh6AFYxizCwDtRklFMiQzHhLKTRJuOmvPV7cs11hYjLWP4wXwBB8Wbt8y+GIUnxtOyBWOwZ3PhIu377OmO/J2JIpY3BghqXBmsvGlpqhgiS/PrdzAa39BrCe8bjlroAjObDMRFCJbiGWEFyBhC+pnQJ9WDkiNX0jb/U8e83DGQbqM/3GgYy62NZS5Vt3x189CI9ATc1WmE7pzaRij/vt2mwpCf7DMNJ68Ix4QUEGxuqozVCsaAg+yN2ONMTucn2AJGiUvpcEZ4FyOgMW6N2NH/BZnxP9Xq7VqViNVZAJr0hrQQM54ItSctkXRwsbPFEsonQrhfUR0tl0EiLSCzaTUZWYRqNJKQnjpZX9QdYWo0KwMvhilJkFYHflCzqV6a+WnctSzbFnlnHo16JIa8w6r4Ep3HNmsLquBU45X+EFBKHIAu0f0icodMnFxU/92GdSDD8rSahGmz6uuNBBuaTzk4pQR3XDr8owic4nvgUm3QqhW526GN8/a1C/h73PPdDLK+e+54Nx1SX7DeSg8cqIGVbZXMD1hNupAStpIbFX90/Ezl5/HyAbpQWYLA4jNCrEw4c0HBZu1EFBckdl0gUmPu5/54/QAkby7EdPSs+b/Mr+YA4SWkOylO0N4yKyKOlagePvI8a92PJCPodKtdRFIicG4GT67g8PhuTJf+rs0N8C3eYrp+wZiRsmDskDVVAOuNdjAHX0vQM0y0HViVJ41eOgyTSO8shGVTCncqmBFRrnielSzcmJzTBLPdsI9jMSxrjx0KgVwhkdM9We76lKBNwMmBx9WSly/Umas762nLo+qKWIaGeABPAWLsd878tCy95n8h35WQXJBnFZCwPnDTg2f64dhY0HeG9kWn91SsX4K0VDAlBSGbeygvUtoVUUd1RCbpVvWNHSh63NjwO2PtgoyGj11oVbOGMG1UHLHOHS0d19FknbU60H8Qdm4XN4RrqUwis5Cu95vP3dHlKaEeG+lABJIMlg0gHcIzgqTBbcxTJwxFt2uwgfultgOTCz9lpnFYX0mat2hQYTmx6OCr+nJgtvdjs1Dl8bAPGmR148n8FH9HHB7gun71nYyViXjvAyxJ0bZcoG8Jnn/XVyrVxzWWPk5pSHTXDXjch/+acNtHJqHQe+0ej9xupIczQ5Z/eJdES7xiJKH1/HhprB0SFcmZy8hOzqGDt673Jus4sC9tPCSvF/ckJt2vENiulW0P+ptAu1Sv6DYui8smUdYov3cg0SfdCIsQeJYvOv9CqpcnxIRaWbZ8Dg5AqlsS690T4qng08d6Xk9ib0/NGHkGVwUNBJu6+Gfnc0vqdMwPEXUxztznMR3couPaArDEHyJQTE5b6Im4WhLjJaV1JAQf+4XgkOX+hXOGhE11cQmtNS4rMfO8kcCSr1P3B/UBqIaQjtzTlZUMk4We9hddF1ya4ehqFuG1UuyukIwSDpZM/KwrDNJrckkLXbIv6n22fw5wTIhmweJMWWjOoYASglNJ+O+xIuN0TOfAw6cgR5nsK+UwwRmKS8lMfgNJc0dnwnM7+vsQZZxV1CuX2yyamDDirJp+HTctIH8pZgpkfJSWAnHvwSvKSHkbLKhkN8UUdcvuh2nX0XMzQQZsSdHQUc/w7F/glFEGWHwF3FXxw70W9goiUgh3Nt/iFHf29bQ5+uJo6KqqCP0Y7QN85407pk7nX9l/XPAPiuNsrxNempkwLqqPJw1zXaZXp1yz5Ll9YxNtB880+tF3ZzC/FjwZ4RY7D8+hBW2AlVHjAyaFVJnxPV9N6sxWkpWaJzkrWoPcwnau3kszSpy404zpqKzWXO0NtARsasp04OftQ4mh07Kg/Y/3Vbb5L27NVir6gITvE9vOBbfEK3ApPUXTln4eMAk2clGlIcRKuA5b0IfGOP/R3LSYXogQ1fT8nzaEGR48/8idkT94mp+Z1OerFGjCWV1LPavG0yPixD+Ayp9RQif13qq6hlaMKzY2Ts9jb6HCBUaZbLW7Wpuj5hGze5si78g4RMvIYOuTZs6tTA5L27Wzzbnp/nnpyNW0bsby7izPNVi1jRvVdD1Uvdn8TmwWSYnwpzfIh/7aPEkr0kqDRJrSYsJ3b63PwklVzJ0OdeXGBLI/pt2j26cuUdnCe6iGHe/6Zwvt1O/ElfP2uUiC1/Wnxmu4h0MzE+W41V1mk01ZBg6Gu35jpFwVKrIgVw/YIGHl5Blpte5a/buf7uZf4ircS5S/vmsLOiFBn3Uzxc+TIkQSOP9NcE8G3nLuKdtVRQYaBKZrhA3BOWOfw9y/xF4W1BqFxYB9zgVUynuwxdDs+OcdBR4V10u3DuG8/h8K1AM39WSgE7hIjx6KkI00lOMjvL7TEOfsIHDIiIdkSiEl1gdESpyk8lEKm+qJeBaa04u5UMwDnnaeXVKPG1WmYOjpJydZwT6AR/PTTOc7xNdMrbJSclwbYszFIq+vundWUchkSzW7jp+MlDLD3k29lHXz7tGYQo0KKsVNTesvYrwsjOOEzIUTJIviO28ckoNh3Iv71kv5te1EEb61bKyl36+R6UfUGOvKcPg9/Pxgeiicl/sufBxyPVESmCzFxCRkeDZ1/CaznyXHf9q4MenuDkqmA5MQiFmy5rjQJk2kpLexHaLItsFQxMz5vTEM1ATviAknGEJimWBG/E6qISTA8qCp+NsAL7IFiIkU5rQ4EeT/2XWcC1BvvIPqrtVV7yMh3uqxoV/Yja0JMRBuQGa9KZ8pxZDmjkZnniCfG9B3rlOHIs1pAFilrEg0x6S3WiDFY81CpvI12740UYopavmZh743w1AFztV7jsSJkDLDU7FNO3xxZZ0RN6w88q2ilvRc9mu87m9O/9IaKEU7WvQqAQp+NE4OHOdlfSh+QVJBn+cW+QmG9ihvAgbZ9olBqxjIe2ql/LXrIRNu4nknmumELLZMGthoPJaR6HKve+/IPJSCsezxD0psoo2cOPl6lU5Hlo/hylrk1gST0GBRn+joAKI1aiQ+O1ZDza7mZ+Tzfp/eKAAg+EmzRvB3O7LbOgHDl47pvhMRInT84BzU2aTZEWjLX47RUfRWOtE8cZp7NawYQQTJONVTKzcvIYU6E4nnEL/OH2iAz07FFVFi1byBBJoxmFpDd8vqd2nyY45xLXCyRfPeM4jIyssvqJ/t5tfRrWEJdJaAKGwAt7PXuLjvAVLv6UJKNp38xkwn0w+4mmAAnu//M2nM0TpyNuNq9sm144BkYN+9oNJG1tc8eS4X8Cg7Wb1+KsiibusRzc5k1WRU9Cdva1etHbaV29/H013AL42x29EoGU65fhycKGqNPi5TcSO2MXAuBepufQe4HTvjYXiawO+Owp1VIzHpznNOGG+rCtoTScj3bLLboE+LGPek8SVnUWVJgrixbTzSbm+AyHOPG0wbWoPSP87GveiH+vI+cNvu6rVEkk+J2jHwvU2TI4Tom8K1QEAiRA2dQNfFyBVi0cacADQB1BeoxeUR4MwXjbt2F0JCX8GjmbtPx0E9xG+mY6UGddYK1sNr3Prn950Q3ESl4jWjqNXlnxUeSKK3BodtFZq19L0CAydUUW09yK7MImQ+tRSIV3yd5LIcJYMdob8oM1PcD8M+pIx/fc7AuPpnfnvd1kQj/5uKabbcLSUqGnmsMOzjynFkBZzHhHER6sJWAcLdVEgRHc0jq+PsEhCPt2vUwdyP49VgLCIsjvG1yNAuqWSxy6GI/8eW8lBUpyPcHRQIqyYr6srgUCDjy/KtzYFP80AMFFWoWSW0HMBngFRxPr6adIEDQlGsL/+aw845rt7XZ/LiqXVXQkvTt7uV5TBO1BwrZWXBhlE8dJgixu5mU0DXY+zrXr2YZw5YVoMLiE3NWnSG12e3mx9O/QH65GHRf7TzzYnvtx1yM1SW/uT8nj8EFJjsu6yhJTzHI3omBrQjr8PzliGWCAuaW2oMjGfzvl8Il7ZLAjNL3gxbYEhK/nseYMg2gd02dwz06GF+7RBJRV3UBR2o7klX2ji08ysk6CnyFj4Kz1h+IlIKyC7BfWnERd2P02cF2dNJ6bELHrxtUot7MTd4RYIXg4cWRiT395bngbzYfv8Zzdedw0LKatm/j2BI+/y7O4ZKSCJKttZefwfm350DVwL5ABmrqVv8vzzuOufIjR5yTFogWV88tUw+lc0lvZRFpFNpnzGwPS0gNvxo1TOJwVQz/OW62Wf8j8TlTcw4jGV7sDvwey27MX1ho4fti30M4tCPOB+WSlOqhTxCwWmOlUk6oAZUAPlskDxxxgv2eHEGx4oNlMfRweQvUQD2mz67iQHxOhUGxB6xHZEodjHDets6RxhI8IhF1KwRj1gO3Afk9KAfpsuj183V0ztkHD1zH/SWKc7/3gZe+rLFN2ghhlh/b/PKb+mZlk03KcPpzcQqYiN59XHYZPMxCdSX5hWIhDvHmGxRXAp8MCKyl6qwT8lD5ygRo9/xC4nHxxRm+zDsyDtmi+Gchdw5cRAf669T0bfTv11O9fEdQhAG0tDboOUWR4quXDtfCTla5vzgDkFp2lWD1iI6tsQnEnsEpLaiqmpHtyejNptj4jQbG5pZgkgRCEpj3hFbKHxPenmiv31UviDnIFr7NN8hyjdC+wO6Wli1pjduv6LW83zZJFAuumcK7NUmMSQP3eZVyCUtHrEt9d5IBJf4yjFiA7e6mvpyRpRl+LanAcHKMjtEyvCPATHvRkqrYfFskktUbemS7vhNS9pqg/r0Jq1CRgXbjTfWymurMHvetHMn1XZoDrVP4dVbYU5wFHLW2hF3bsB/FLX5WcgMvsfzCFfUiXh7gtaRtNZZWMb592y5B1zlFf8I9VUSBIjEp6Bz0ENjqIc27IJvkNfIKGnrhduU1NqWGwRKP3SGwc1dXNTQzFi8tsJtKNsoGjMUqs3q0ooagdmuIHTWA65OmlLAdE+A7N8K7qlVPtxMmZb3TN1sHPIMCKXgw/bNxNg1BLlsv+GOpE+8sRQZia8s7jfdtJJnmMZ6QpxijI7l3b4AHEhbbE0QX0iUxHafn450UIqOLEa7xy7u3z6TnWhE+aHVetQU/g0mN+33e9jv/CRzAPG3mUF9btkD6hpu+41uWxbF/pcRj4t5x1v5onE2yRGsRFXXYfJ91Z9vX4//RZOepKruct6V81RTkPxy/34aKqplUP3OV9RqsazTaoadcmgDoh1DeKytGOjypHhMKF6Hky43TuTupgLQttVqmEMOweaGvqpGBjPVKM+Argt3V7TVSuacRQnxtdwfBom20dxUprrGfiyRNYdB+LUQIt16h1CIv77ThPnvJpC8CAIZWvoxFthbHZDETEvaIDpD6oBiiKcOoYSDpnbazf7sSYpd62UIhv3k8uUP2qo18XKupJt+C5wP1s41N2TTf9urX1YTaNJ1I5dMzYJ4BeRt0cldBut135vEqZQGgVquMNAgTSTmRRe3ZngY8ebW7nOpX6zbmiKW+WHAhKU6qaugdT7koyTBoZ4KfZGJvN6xZmKflOWjENgfVEObSRLzWVQJcA1vBVghC4snx+iv4csw4OJiJahN0OXSUkQE0c7ygGWSgjYSCMnDPrb196GGSwC9sFyutL020sQxsKkJs8gbh2SWqVjZv4WAmtFuoBMCd6xcZ0VZOTCFSWVvVFedGr8qKBGrQOYHYxeT79mA7bTMu6vIfMaYhbBBYazFHRXDl80bV5osgvz8SV+i0zM82vEHIpOAiF5CuMgfrZxTNob/4BsyBeVJHmKDEjpQZ6FA4WbDXUQAsO87n0/4h9j5OK4eQsA2QZsOAf8gwwynTOQcuDlbyTDomVtEg/unA48X+zeo0VjsByuf0SZtCRK1p5Qb02EDNzNPdQguZwzY76nrTOSvq/mF5WgHpocfjN1OCvgQauIx2tLr6gSP8m67Nxr1IGfF55/+KC3IB/gkJd1m5jPXyIb1Z0uhkMR8dyqQyh9UsuJ1z8XSxMDmedg+WtXBGJV2+pdgel90MgHYyKNxyhqAnD/R7bjVDTvx+zkCoAtCjbTydJFjYgzYfSPEQSaW5dFzYnF/SCREy4VXNTBYUfF52remp26jaVdgipZNJTGJ8OuYIM9vesekiJ1Bs1WYA1H1H6okZn2CtR2umgh31bjAu7HoNf803SYmH/6OEQL0omoKQoLOxrHgEh24McHxcJxxR7yBhetg4pRLBu8d+aWMBE1CThxY/Nl2uLyHWqCt0XA6w73X5TyEv9gJ8N2g+29SHNfehB6OYOqluanpwkaaaNGLfl6PoFJXhV9LKTm6Ck2gTkgH3gC5cGnDem4XEGkzI9tc9PzyOjRSDmfgGx7PufWBxBtvW82Bufl+0spL4gzTJSvkpcT9MvCqclgeyoBVn7/LYbCFDLJX6wSMKuvNmcODOLVLsQq6jFOnD5kT7FZ9NZN8brIvbls3SP5AszfJ7pwgJ6i/gAJmsrf7dlKZcE+0No/i05pCdvBOPXUs72nm3rhR9glMFQh2+jSjgBomXcKYge2zsc78m/Z3gVEaVuC9bzom4s/6PuAphnlc/pjvdx8yi2DEHyQeNFUUEucNQi6eyvEgVQryr4WQCycsBxFbX4WM47jFTrADjg/C1Xv6W0FN8G4NNEQX4EIHGyiduP0CJmpTYb39TllvJzmI1EzURpUayCM3Ua4Gjx0jnwxC0ZH92jVGwm7bcGFnKn3bCPdIF4O7Jxzyul1WfW0ve5t1oRODMCKgqNV7zjrS/Pg4G13D7S5OlaBBh5xkDIDp4RTorFlbRp/IpfKxFDOyYzts8/vcvD+gsc9EABJRF+KQY2NwQke/J0GQDKLT5Z9W8PzkcwtrswvdDJTusMCMVVo3cp9mzcrtRmfabf8U4JeN+n47DzP5kXX/k1asd+2IGH1YDOkAPGt3ovZF0JbrV+TOyA7TeGxOtzJt+QWIsEu/wBMzc1JO0/6+beuTNtAUNOVSiY+/ofe+dHfR+KdqM4NfbhtQwrSmykXQx8++kH+7jj21fWH/WQo7lYRm3Pc4vOTRSmzLLdTBqMMMcmTngbdXSe+3zU6/xMkfPRsdLy4YAsjVuX8NuhOZ2JKoiG4xV6jnGKOpFmxgR26dHey7ryDvJI5g/SwsoTIUFGNL68NG1VERaqy8E8wJAsKtvJuzC4umQ6GXnUAha3uscxEvrwiJgNz4HxZIBtE52AEZBGBtb+OcQh2DKT6LY97uRnTEO8Jbs2shc1CwcAvtlVPciMIazI+1jq1lt6cifuEetUinba/NXgwZGVs/1foH7rFoKDwyMQDgqOFD2OiPvFGD+axt78/sOl4NSY7jfyPNE5T7wdXVHFGdPCkHTm3J6UcpVROow3yKn1Cd4TYAFGzEiNiMnNKktToU3w/qznwqmi5UhI1KQKC0FfT07OzFUdnAzrxdqWNeK4vVHUzmSOsQuv61li0+Z8epAWsuZ/SZSXUUdyvvZOxjjj0VGnXVlCq80SenLOM8yuO59sYwO4wiZYouiTegIYm7bN+8csHIn2qRfe1P83U611M53+eRlA2xUP92Zhm/2a3WRUWZiENFHscVyn4Ji6uOXJEpODiOLzEhTWvw/k7cpbLHPYWl5uZ/ble+xLEVO6l7ARUCH65p2g9SaksG3tQM03Xp3toKHQeQ985hzeRVLoVrM/M8a8snk932ihyf6QhsWDa9xsDZrj7NlspIjuSUslVVr1C7Md0QSj+WMnL/yg95xZgyHQalfD+imJXrluDP68WVdFp4CDNL7VfOVDmM4C2/HhL40WX/E0o46CCm4pu7seJnRZtiAMOLkXIMD5/jqOjRcb6XVBDt5SWU+YoQwJa4vs98Q7TmlPD/VaTxQXPNPJu+m2shofCO5HbVqdENPi1EyQCY1rKYJ9RguF3UVn7easC4Z2zylvEZGJUHuSzsLuOF/rXPLWPWtB4ypaB6LyUNiduuR7910aAhqt03R+IZBs1HGPKHS9KxHLCDvp68/CcC7WUvsbjpQzp/hA88n0CaI2IzKeZyuDvNroaSa+fkHI/W7cxzQxtUwI59aMu2xPyof9j1FzxrRggIAY6Qm0y5aWSQF40UPnygdwj4/SwrdkjqPh/uDnM7t6eEORnDdn/CU0TCE8DVJm5t+TsiA0NhneRcNc5X1hMmGKnivXwmIWAWMfMEs6Uko1L0bWyhYJ14yrrjoldRVXyLnUTPixwkS1SVlMWHowkUNqkPU8bhzW3tT4/cwwaY9tI0tvNEXW2+SZGGxdYwF7N3udIPpXcs0VrZvGiTi/7RPUwhFrdQvnkgrmC+TRHh7i9yZW99wh9RgQn8Aw4F8RbM5kowBtUnMhf1bJcChS61kGPCeFNSaFHoRIPERRwsCqNiiCYF9mCmolC86LuU7uNsOmGY58Z3iNNj3yS4rtiB1OvuSk0/vT5bNk2bxVW+L0pYZWZ1C6/SagDE5bgJqDVRabcm0EGi5jFUwNcQ6TDCZJT77/pntS0oBDs9+wq0mBSxCX9X+C8Mt7/ex3wTq2PGR03uyjvc/6ezkIXGH01IaD4vWbQr/bC8awuLA7QTnUqpciaNYTovxC8fXt+lXWeVYdGbbVW/4KfHZG+gI/vwh2xncp7dqo/ziPUzEMOuhypY9Cp0IR6JLjUDMoJtwJe0FkVGWxb3Mt4WO/ZCAvRsmGt99kKIuPtru3MOZnd3AU3qRSorhVUtcNg/K51UqIh2f28A95wNSoNeEFHgm35vuV85Q+Tz13GBQnolQU6t1nltq0u5KO9adxNp5/85gSLgaA/7gKPgrDBv3o+i5kU9Fe40gKXirpJ3gSd0pcNnLMJvfd3uyjRkQB3VPbyJkrYZZUO58oDTfnSX6T2ATOijoIMcr1tLv8u6eDpXMlhh3apAQ5BavF6FFl7npWD6UBDBzf2axqftQLgGY/2qi7h7ERfcZnBfLYSza/bceuOrktoKN51a861keYBTos2TcXGuWV4Kh0KXQmGTn2ujwj9pItXZ86EJtsSticFzxy1tJcn8p50A6GaSRaoYNINtBxgI0tM4LZMsdbZ/qoxwarHmXPj/0oYhMNDHImCeG/T2pD61BUlCWaWfb78iowyP1aWZ6VWmkeoPtTGmoR41mV4bgOMhSbUFY+fGCmAXTEnK4bsADQsz7f6L6yICfb1CQBkkJJwmKNrvnGSnZIEE054aLJ69sxtID/n1fQdAh7IBJfioYfBR9DGmlsGBbKSh3SCh6YEooyf99XYCCMohx9pjtSYs3JB6KxKIioQ81Zn2mqcCZnsnXjbcGFOudWp/J9C3gIyN5fmns1clzhTRU50xFuUgo7TyW8P4Eoiv9xe/X0dTFdNvX2G/BWmJ66q6ZEvbrJGVrZI1rp24xwCttF/LlvwVBduKSWFCK3IQC+/fQSzswaHMDnF4orYfTZA3PTe4mLo0Uin7IEWBh860DNd+5mGc6YsFnYZhnbOnSWeXPFClEoS1AMW5+FJMgRnkywjZvHVViTX8nhwijuYwDyn7PyndUECQai/Accw/ol98/sxp8lfPCou2GFKbiUQPeTaQP8mMdLwcauehbuNx7FROFDP5Zx6iFZfxnB/P6M11AbC147DxxF/rflT9bY7xZwUa71UM5x1Jvwe1dOpLSniQ4YJ3kInUQspCHUBo8lcWu8Mm4LeMe2N88VMSPvC/ObMhhZpR7H2pj3o4Q6FPeOlGVzZIzQRc3Mh0N3tdw/kuxQB0FDnNeIHA6ws1fUR1eOKZdyAxw0CqLSHoF+z2clU5RRu8V31GNtHFAcfuFtaAwLWXyeedt7Ra9fuRONa0VvcSQIG7n/P03qZ+T050zU2k0KBv8IpIFwSXx4CkUmNwNfwBPHnbLrI+75VA4wX6XpPbU1cAg+Pe/516Ttpfr5cxe9iffAUhotn7VA3OqXiti6MrWTNxecO6XUQdAkolXJAJSANxX2sbP80eVlkIHdDDJlUth6+8JuXnMrl3fgfxNYGgSWb091bMMP4p1SzXpMhEiW/fe7PKBo0JZs2MPyAw4dSWEaesCiLwc2XoE5/BtnL2jEQrnL8s5pkvi4+uzBRDqvC4mYJh2x29oaPG9hl4Dm8jVPlikn9CO324MOt0MZQ3eZ6ip/9HrEXSq/C/fcIOU4cdNPXGueqmRsKjdv1s3bdO1YXQjrg1R6Coy5Wke3ansZ9miADu5cmx1e8MibLz+90A9o1m+ueJS4jgAgznTABJj99ZddIoavgM6RF1nRqd/BUSLXUU+G9Pg7IBwg0UnlWt6NdyI6gjTx+aiM3zuPqoVYypK9J70bga/vw6cBQDhzAgiQM9UuEMp7s3wLBEiOxP1TX2Qcm6IX5pntp2fau0KoqeOcUlHo/Ytm0FMpYIIDF/oc8zmR195X82MHXKB2z1XA3S5BdeiAgI4nT80dBM2Nupcpy9HNOfy/7CQ9CjqudMrR6fqn+nIewa2u3VZvjmAvqBdVRNOtZmI6ljA2icwauIxAeiE42Cb7RMjWtMQGBTP3xtO2jgrODiSQ7h6P0ZYNboJXglZ8chV+z/y92mBNBCrpljQV3Thpf2vD2KBNTjh0xh+Zz1HWXfsDuMFhBzDpkKmHghFzeOoRAFN/l1IGEvHLOanQPO+worWdy4UXDkTzZNtki9KfnSh68jebGLveO9u+zP+L1P7uv999YsQqJlFXMalcJfw4NxOXOAQvOcb1cppD1Qa8s5Op10wTn6lvjVcV/yoWOpwspjT6tRlmm4lP1co1+qDWWOdENPzJg0XfivkQHrloSCR42f8O7RY4QkMh6bAjKoTQ+iUAFkqovosBdD2kfayC2wMfOHcIZs9YcJHOHoa8OTpfX+eAiPODdVxB6JDTGPSrivfORcuKv3wT77Ad3qy9vo+ZljoqeJ5184vypTzIQ6utYL+oFmpZti7uY1S6CUK2er8sw0OCaatLNEUpsDD2g/1Je+fSNtytyhlVwpyjFU0rTSUgF9kfn/CP6uErSoA4yHlZVZHybOA/Pbl4VKtHjUqoyhlrBc3mhA4uRjwIODG/9EfuEO7t9tToUgOHY813TB6oAv45PiHeme9/AT9R1zP17x9UZsdJq6PJBt+aZW6zgsR/5ZV5tP/WV+vIg0NM21gGgoMTFQXdaIBbz2fI6LlcH/v0FS6F80M3T6cgPCcN7DSpXV235gT4gKS4wptU7KGVW1QFvCCjYeg1aPkK1pkG5JzRouuYduikQg1sQleH5lVGh1T6o+VYVUT4Hrm9E1MaLXj9pxv1dGGhK894LRMZVoow0SxGCuSMhho7TROznRcFOaADT9G3pLMhsRFzizsm/BLGNy1lthzIDndRLV6NfSj4JbVKsddd38/VC/HPVJZNIAqC5HhtSUtCjVJyHJz8zPANudX3VSaPrjxf8nSEU4rHJoSV6nNPZH1ogc0MPFnekyQeVhbsabpl7sEjGaTufrPs8PEFW1Pscu9RFGSshMIGZcEwQ1YLpCBQPr7XT0OodMYLVYzNWvkEwtG3E3nfgp1Q4msKK+sb9hw9QBOPcFbxDQjsPdUF+EVzZQJbElXxfntcLjIRJYJ2IvXSLegUYtg6kDMPjFJsjVsPDbmYs/xdIG+kPf5e7NO7B3hiFNmxhJHw+021A8SLyhJ1LKWIiSV35/K6TlQQ+rOc0p81qzcL+veL9ZflaSKymr1nHxFhe1Ghp8CaU4X7u13Ke3t/r+U1Bc979DLR+F3Q9/uHc6TvunWwQsWeKD2KvAs3Uo6eJUrwNI1AQxAW/6/yE4tWOX01narmbIqcHe7c66thtMihWvzkWc7+FQ8HV7G4l7+TFmuPHtBa5ABkwAnZsZtKf74KORzoHH3ZQgf2jHeOit11Csm2NS0U2VcmIUJbIhBYtd6Kv8d7Nx4TyCojL+qaHXjHwrHyOLx1+tP4ElWl4Kw4+ipbG7TVMkwdIBuaJWbaUM46VCf9g0o5Qb1XpUaSlXrELgET0ANf0UIxAwoRaAWSKZbvIJvLdB9Z8lQjxwR13qJ+8JCyjRWZ+KrsMNTOJg7A6Af4rT5jBS+HgHOsumrtCIrJ5CB5+RJ2S01KYV3dvaKsmTgHoBGh0DiNFHRHffYylej7yOL7Wu8rGP6YoZsaMSduWN7PrsuJPHgTJ+QrSp5q315Y0pCQYl4de9btVLcA0DIc2K+nX1/eh4wVgdydYOIeQ7yTemKD5ZQNhrHu+lYM46CNhRUl7JYeoiE+4lEdO8mGpL1TGcGzJ18LXo0o2IohFKL+PyJlRd4/aIx3PkRP60T5KUJ1uyU1vWo4xhdYXVapALlBIYkuYJDiMrKWyybQdqJ19ybDy2+ee/fW0Oa4YbGKOq1kCE85BbnUVin6P2tl7Tx1HpQmob6/ubl8hQ5uV1+x2xjGyPxoA+Js1XhIKC9HVSE0019fSLQS5ufj98RUYYqACvcCvk4reSNm7X5l1MnyeSDtn/HXGue56xmkp9Iz6SoyD25fniGLD/FYkWBkRofG6uN5tqVlzQZ80GoPrNI82KOK4iz2kxPGi23joeLjUGgTfezqdEkmKXEczciDAbdmPeqNsZzvqmfIfXbQlS+XyBMkGCvMe9YcG4mKFyRByW5F/lqup3r0fhowWK6XGzvbiCS2MampfjIv5vJjS+wGwaZ011xZqdNllULPgxBkBOO9CD6oS45RfpUurjxRxH78lHpoNNY/+T1VeBSo06nHruXCORKItMX6H5bJZbXWZ9yOEVbG5WHW+gyHkptI4BTlM8fbOxJDXLlQNn0wYQxBom8GpiWKCV5U4VcLZ+EoG7b2sDWytmoBqHOCDYSJwk/Ydtp0XwibQUN1zSy4YXgfDtp7BHpSWoR5LzCcZZo9KVQEM9oLAoGI+Sq0hva0byWLVZjA9gikZGkH025NfL5gW77DbY6iHdo2O/g9BIY8/ozmVrxrLJuZJpo6yHS2kyYLcZ9XnarzMpO3ZAYzQAjyDu1Tz+4s2ZGUVzBZF6SBmQJxZ64Lu2bmFM2se6Q9zIRp0K4mb5BKYqJdqeHHaahQ0TrZqr5zbMTwOeomFQMh6GeaBQzn5ErMOPJX/PtX8oUhFAvP5OZlwZowxoozSgx8jw4VRlRRZDHJ0SuGUxAFfR4r7YzC5zgpiU+ka7PWz/RrFa2Z/sXdQe0YeeU0X/MSATz7vRz0KFh3KtnG3RJh5+lZlNWAJSV8j9HLPsNwG6kuCUN3pP+HI8PYQJZ0+UehWgsy26Ku+MPnWKYF1zaguu37HNtIaDwTRQJ0vsKq3OETMI9nZfRQJmn0Jp8AXA8wB08xnWqq0X0++Ev0bZTOf0WTVvhRidDdlEsrS5WfqjAzMGtShzUgwssOCA4/Dl5IO3ees3gMMZPx1eOZUjMAbWgsFDtyjceVOf/Er4ObZJc5k1D3ZRc+KyIdZvl+U9lx8zA2iXMFcXLLi9XuUncXw0tU5O9E+T0yqikGpJwFTTMmjQBnszI/PLHsa3qOIeBHLsYBeeY1NSnfb8q7wqQMPQw40ftrDWzgQ6iWYOF3+SI7/ZfPTW8GWT9qY9tWdyiTd04gFbPzkpX7P7ERuOUs7ioQQgyiL72ypeoA61fo7TzsQCwQ8xuVOZ5mqmZr/b0amSDVGMNaY+H/N6vuatJxBmsNVAJi5C2oN13hMa50YMVX8fqhj9JE6TpZxHauSJteMzhufmseSKsl2yr9NeRFDRWp9OFxdjY+ENcIKMMz+Meb2qvDRXnlmKsEpwEP6fuGgWFqYhpmZy/4omwOANdBKZmed7OGE6oPa5Po1eXrZfyPZcYZgkWlenuRrijjySGxn9wldkFrQpZaZ7Nz74KnRCjDNnrLj6dGo/WmPNJxUppPCWqk4PHz1f7BK1IqfVODaOXGoOldnaeWcpHG3bDoh9CmV7sSNrTZ7h/hCxmPNndiOxaY7UH4jaIxrC5GwPCFQfzDqQ6vudm3tL44CWaLkxB2m19untKO12dpHJLmsAbpFMgB5/LRaCv88zJR5ZKBevYEt3J6b8zkeUTudiDkT9Jg+xY2MOZq8j0YTkamd12jLZKXbF2vB+PuBeRB9iIxT4470DCiA9RS11xCq41tyT9hP1eL7ha81u9O8/y/Ej/Jy8kSza7m9GWUDECnlBz2as/L4lgad/ZVoLKUuJVMDccjbRVJTyb3paXtJ7G1b4JwIbeHj8DOFyozDc/HtEZux2VZhXo5W9owMyxPZlHQN8OCdeAEwNCuF9DTXOBW8gW59zSYqMnfqOpJppuLycPG5SHOZLB+9ZpFUg2OXV4g5VTiIjOnAjAiHs8S13KTIPSG1/M8VdD0a0NsGHFbhF+3hUKG/Q07UN3zyYge3aVSFtSmg80VyniFWRQxjIpCQkmkS+5B3OwazWZE2ha7fVWY4KdotK1uc56yFQgTnAu74t/j2LcuoYyoInPNhIYuSDWPxiX5f15fiIaXP/hDPliRXaHbzBhEOuuyZfWC893ly+mi62shthE3B6IQhSlVbKklP3/72rqtQcgYpFhdzg+SlmVBV0NlLbrT6Yz5o73xkdvH8+o7yDZsDvNBrYhqnP29R36xP/10k/4TQApFC8zi8XEKmKCdg69RGiixHHTAIbhunjWbeOu9OQ6HBN7uuYHetYhIDXQ+Xjfu+wYkhCfRYZ9EhCHhU02SNr/ht0B49oUdY3GDlLniC2qGcv+uXBfQ0HCnr52/2vM/IbBGxBUes10KsemFqbFtaGbTkMaS17CI6dHGVE5voW1CRB0t/ZtxAq5Kpd+0TdKM7aaa6XO4KEa3JpmQ9GTrfjcewy+OWnDy6Pj3iS2wTaYMybDBV+1UBGbvo2QSDtnUdv3udw8XCi65fOyNDk0ekFBLYNVRqxpn0Q4K+TOhPfBCruf8YQVhFnr6fx6pIbbd5An4764EF4JH5awVb2+UwMbCIsJEKy0a1Bnwytit/4NjWCd9002AzExngkvf1bUYvEpQZlnmhShC0nfjVwEnj/SFatdnj+bWd4c3NOuhdFN0GA9I6+UrIjHSdW0QAu2tDWKfAXHfOjhU2ZLZLiPdU0oxmGIvrGkCCNN98lHPyzQb2Y+k2B1NLjuTii8b+j8ac/w+H+1SG7d7oq3DoPaubIQYHW3A24+wQ3XcvktXDZur+PdhP9XPNstYKNBK0tquVO57crpsRcS51REEdaZCI4p/1KvMiqx157F1SF6ZMx2lRWf9DGMI4O0rjgV35hxYq6MoUwxLK+zpa2xK2vnb3kqSmUr+tglHCN/WS4zJ1Lpsfttkm1b2GTEl9zdkSb2IyslTeECmDaP40j3Wjo6k3eSc5EWZfd9cy38/GzuYZ/NkHHRgtR3/8RZzz7YdbKT72h9mbqZZ5Q7it1T7rkhZ6De7rbKjOiD31FjRhODCOLM17DUCq+ZnPKZvG3XgFBR6WWviEYqwzNUkp2xH7hrG0BSAWec6IoL90qE/cCdrwK2ZVhOw+0TzTQRfJhW8vn4B+jh7CFfNfTq3Hi9FhVguJr2dxirku6AfimiV3Z/DWi2rWoO3zO6ZsQSzckX0gRVgavyIatZfxx88I7ZemD0m6YdRj8b+jBEz7TMoW8cou5dUm+cy3MaZ0H/VEtzHq1L+PtwHF8o8mQBag0l3K8IZkWI/86X0SFArggNTTWLwE1Y/GwCr8w34TVi/eOEBaTiUGzTVWBREg4uw9TB0CGfHoEx42OOtRwYmh1WCSmtWZd5ewMoE1lcqRjDDK6PZxT9cQBDb5ZQOyAaCvW5Ew4lgKnndRfZry0amW18G2diRXdvIuHDnMRq+tU3cAvAkA6qPkP6Fmvgxh2THSX7avQmD5YbrvVtB8G+XEVJ3kYZWmO5atAK4fueUPFKjVQv9d6yZyy9qUHKRa9eQPMmebHx5d93V0fXgLYBmnMghTBX97w1vEJt0N53AmRwkBYx3Kmki1hxLaccgrHVwDmtG+Cvz2uBL9+2zxP4mL8OCV1X4CbxTBeJJNxZommwXBC84APaRxHAqgC2SGjAWZIwG/5elu/zavklaTBjqzmfMI5+wVFuoe6P0NDQkBeVAS81RQAyLKInNb8fZ31fvWOV7uZ6nRXwIVtn/RHHTGl8R6QewKB+7tEybMF5Vh8o9bt7JJjNHY3mr7dhswUM6Yq/B6CcGtv+uMLcE0zReHyXiDbguhzQNj22vSxK598C0V0Pr2kuHcTRwSQLBM1EqjrcUtc4etTkE/2YlkxKfQRRhXDtC0T8/Gb77hYGQo4MkJanwImvh5YSoXYafByakCRa7Do3nGGsmy+9OKdrWCefWw1yypWCAbyoJAHY8ZMMxydKNhnCWa55+CImTpq+G02uyLkXnxJF6TKPN0aANPA5evLhVECOeku/0OO+sDGAJqvEo1oBXxzwjo+S4bGO4KeNKAQeWZ1jiuhf8bc1jy5hRsXU5/3qw7w9wLr5z/OF1lap3/HkVrDX9rUelgzoyXihyVNURjxsr6F+epMhjTotGDz7f9GrOgrLRIa3/B2wV5nVEAmO09QCh9zlsYpxfnKAG74bpVmcJIK5w+nMdMJKJqZ3DKknDPeAqegWcZrPsMmDtq3Ct3Rjm+hj6NST5r+6yczfipd1PeePRmyjTGHHO5UTVrey0i65jJnza71AzPhwovhATWmoQeQ94n3vF40QaRUu/zbs5brt/tyEDAyIIBQdLnLo9xKPIOUo33jj9YWYj4NH608DxcAJlmV0S3+Fj6oHXzWOXYXYrnhemB0zZBTiL6PLaIoTbtp75DkwV+S6BfwtqD3rUGgXzFh53nuZjFT6KlQOwaEYACC9m3s4e70kRvMZAdnwaUaW1OTPrybMjNihkIIFVNSttOviZh9GKMOXTUubc2rWK5P9AF3adPBxDhQMvZwsRjFSWw0c2/huJE7q8cTpAdh4kdKZd8UlycOBzMgvmJD2aiQvTzpBm+52sn1CLAtFaVDZOoXitxy4K88oHJXPjRfMzdBuIbOi2Q8kNCtN9FzqB3o7Z83Te0zakpZqAZf4HSurIT5r/kcKXa5xB+QOwsAxY0nBrLf9toqFpEGg492qQsTjKpDaSQ2OKbzb4GaBjV1Vp/hiSltaj4QBr+STijWMXw2ZzYkwDE8AjkRHohiWkOWW8u7379EbiiPbdJpj0gYfDM9bRgGrNY+cbY014xF76W6XE6jm4CcnUSVAWjILBPBfWlUzEw5OjHoCuwdlfUYG4tLxXea35XjGAPUGK3ab3CbpErb31+bvL2H2ZYJvGG79gIk9hmHJIdZKRcNGIjrUK68bLFIp/ht77gbkjYgbAE1DBR5UjoJpyB47F0pMpBopG7HDrt/G5KHvgpj9sh3nOskBY03jl2GY0jEw8X4OQGt7uewi/XddkpnvUzZbu05LTccY25TdQ0HnHI3jhU9hyiX5QrVOHghBtu5RaXooEENyBISYjFXqkLwYUiWj1aL1663UjVsWNWLmwGT86rfCC2v/djn4FbNx9Xb+mI4E7pQx8MXW08YE3yZVKuVT95KKv/JQAdDsgnwARzLS4UoQ1qNEVSjit2/Kx/o3jVjQFEJqAH5Cpd/seOpm1GOH4AbazuFjox2V6Kf+Atev+BNFnguMU/+R7Z4XiiLVOCNAPWhEy/ItUeYBfj9OFEtegD3AUfGLwbMG7ESIikfZW9FkLKLijZVR22aN4fsTt/rE0B+WbUsJXex+5Wfk2nDjHja+30yms0/t3TdmxY9F2b2KrEYM9kj2VFsPIhyeRiGu+kajXs0+XVXUOc5hWebdKOxEtWZ3Q7bODGX1OShqFSPKNa6GSAverUKcLQv/UC+oBm42a6EZFv3giiSbbU8dKv02I8rzCrlFkJ3BQWtCY7nbqaNIaiqsUYNRqj74Ip+EqewozPz+cc0Wod9OSoZ9aikecvP/21NcCNyHS3sA7mrOD5vXnVmDSWNUOe0aam3kXaZ9mrTj/JT5XkDus4CaYoqtALDNIxHvXdJbqlhvHKfzAs3Dlk1UIS7Izlacb+Ek2VwMVJtyvSEBzqKJaJ4gNZNKvr/laYeeqSYm+J5xTLHAkYrUE84aOFyYPi25GsXcl9L+VwobT/gnF6KG91lVbQxA51psUYeFjobtZo1wtIOqLOv1i4jjOqGo9GmJnum36ycg3N2UAZyQuA5tomDCqUR8+ag9MOEPHp9NGs7lMipfWkx+TCIdPEppXDIY2NUzPC/hLcr9fBtXCLBstieni3VVuMfvfMwWiCTVWwM87GIaF8VWi1sA62MgzmNYiv481oNRWlNtgZqO+z6lCixpnmYXS0dD2M9cFlxqYkiCoIiWmjcRKrZrVp89r7LrGiekIGCKmzOes8JOWZfD9tcLRHbrC0DxfQy05RnR61NWGi9fUvW/hqa3UelM4Fiv9vwDUooe27RTqK5p7vvaRa72XhSO8DSQbxuWW+3lbV1gWUjYQdo03iyYxG+D5QYYeE/BfiXvPz3g+PraZ1NiJJ4VyHdATlTWCiIzk99hyBEf3UNyQv8ex/i69td2cZx7e/H4dHfajnTq/E8EzOoA52R+v85ncJsMG0WSOnVzk7FgkjvQO3Owwn8CR0KtjmEip+p70PAhgXdrJeXvxptsk9IOhjuhOYDB3/IMO5zzykiUDIK3aDHg3L1Kfksd3tNwKVVHBP3ne+D2qV5gsm0BQF9C9AJyNJDAlDeSmLHB5xUWmWdi8rt/SPCI6VtQFL4fhwm5btdKIwkw/xI6Z+wJcPELy5y5mOsB8wY2TDm3wTorm+evtXrDCmnY3/RipfLIxopv+BSTeqIlCzsi2magbnwFBcuurze1i/ubKH8JPAVWcINyB3gktge/fovH0/5Sz2whtLz6SIHBCGklfxlpfG2gTOvv4whUpEeRY3uZsISqqYXMvWYb6oNKAsHbRwuH1XPr8Wb007aXmQPj9VX+2wbuCCmap30T0S3+4gPw8TM8TuIK87yEE6zKkpVYPd6mnE00AOnm+Vvm5SgyBWvVH/MrDvL0aU2j1jtrcttGYCXSUlxrNuReOiVZ0Mlk9ZowfajewZTmXeEjqFeagO8sJ/mes5yB9BwYRAv0uXgeSMwCowrr73Vg10NdWtHvVL6SrVmWV8bDXfjnbOEcc0xsS+wEyHgdD7pu9GOuhwU/3N7EVqzLp3VyWGvirNLk/M/ULEDJqB/0vJYZg911hXpjiXfUechLItGWLvF++EbaKDgnycZYPjZzBx3XFatQb3FH8clkpBkR57PQd0xXkB4Mwx+4D1jhVwPasaXLla6TreKuReWkTunu5NVmRKsWkyEq0I/xAWE1g2Yb8zCR6b7rRTIKzjUsVwZMvyZqY1siXmE8HuKExn3K1gj+XKiZe7EZtBNMRpLHZtaoQ83hYFeRAdWxSTDDiAua0ro0jGWQFGRHfrsjfARnCFoyrOUSPeR777a98EuPvo0H8Lqw4PKQXyMg3Dt4SzwZb7u+l+8Y08Fycy+q1rXdlnwd7b7AUH4kOWlA4HEbNneHZlRA5gqpzB2YJpaEmGgLMkglUt917s6G9x1YaxfuXzsJU1ZjgEbREPtStSm05h7aT2ACby5ZfQGDTdjzDVgaMzZYpREuQ9hgy9N2qQL2ehIicOHl19zoShc5e9AJGpPDZB8daw2dZPPwjCr7ZjSwCjRMd4miMaObet+LaKH7XYrk5w7ERAvbRf34yphNQEaDB6zjUgZvQrkNCFWhXvbKzMDRs7gGW2D7Bxgz4zsbMJvqYK6h5k+mGm+Xuu/n/e0AH7pyAUw3znhujUVVQc4Qd5g4nMqUXTWddMdc/rkR+P7IsgqVfuVwT4wUFGHF/vLBx2/F4EGEdiIXlRwVxLSqXLBPHFjAqo9f9Kd1pPaB9BWh7aCCyhMjAVklzpfYSsA7dCr5OgpmBQ9oLukZIYEssW7z6LZZXsy8TluqRYqiThCvtRdFes3XlYVN2D7f8pEgrUDJUikGww0aQRmjWagZO5MGnmBhO5XbPF8mYDA7jSINPIvV5GzZTS/DtVBgt8arDtPwLCnYfrqFWKKYgfc0mPOQQuZi+QixMVHA9fKu2NoV4+vCv+rORVxR75iBl7aw+FBVgDF4wiLDk4+m0UMIIjnFb2o/gyEIWTqge1G6M9l0fGPlg3Vo9Ey5+/gBNWw/Dkh/YX50XHdISPFBIDLJD4+4+2Kz2wGbBhLfFmy7kcFkiN2FfmULeCLy/VYYk4o8aNOWWHeRwW6uahRJMIKgEmpXEIvMwfYIX9btGpM/d3ZISXj0HI/q0OzRsaVFvSSOBTm2GMLe+TmSRLqKmQyPJAEvsCkmdPmxO06/Z+hgdVlXPWVXB5IpakZPqqnp3puxhBcL+1nRsyPNdqovyK5FUSUSxuUcRI8LRCLjlfOpWBFJcKrhU4gJtc2EunjXYhmNKtxYonKRCYwqgIusGIcwWsrgfpv08U0cxa9S+v7SDFRS2osPgKhEJCtAChcdxPDj4nNrqJs0yw/k07J2/MqGBl9pBsQaruJSuEo7v5DbOOmiSsNiVEXvmWywXsK+ZaxsDZnQP+m9Fz9iuPWWRgBina7jICU6hVfrj5Ua8StGHTWSw8Rdd2kqA62Q5ScfhEmnvGOVujbNzrLrgAcIsfSPki3SlFKZwn0DtVVVfd+/JIVXuEX5RNdRAB8WzJgkvdHnlr4iZpPCTvI/GhZWA3uzNWTSdK7mY0lp+tjTgzhPskQlJPXKg0qm4glAlrOpkZhB68EKqwRpdCXDOgmzlFb3jxhQqNm7fsfCz5xRBGm/G1X1CvFJY0IAzuyUVr8quvkbLvOaHHweG7OXVILxAKWXeuoTGuT8oA30Y/cCtG64zk+glrQMuyIaVqko5tdV4AgrIjOxkOolAcBFFEOLtxy3zG27OQptUqOiTGIyy5t7cBdvlhY/890DHye1gyT01mq+mA/amWflA8X8niEJew5+MIcLlabz2z5d70/n0VsuwFsu8HhpWWwqZpDonqixdlbUJN5Ic/MTw8g6Xtg52DezQAPkBL4Zwprd32KbXksRBccGKJO761E4jRzD7IzQfJoCAOtsReCEb1Krf7CjH5jUebX2M7+squYXmV1d0sJ69sLACsEAJgBNlpvIojUkWxwoLHcXEfuF9cr51ci4ReVu/Zn7hggmrRMyQ3a6k4r7Lj/YSCgajoQLr8VWqF19M9KUTDqfjky31alPDq05tGbQnORnf0vrIUzujUEGyOje4ihF98Dpccude7V/49qC2IGsVoC4YZWxpeEZIrQ35UodA5ZSr3M/CgWCPJuKtZgEBfLl8fZ8eXj4dI3dh5n0DNp1WsKCQWvEYx7RtF2VrWjlV0/ip5MD1gw34LLrrqYiP9wFehJsHkOdUgfSIwTczGoiMN30ZgIwYnbB9NdRame19fmrKgaSqN1GGnYXQ0ojp1gMB66UrnK103PtUBO2JaQh7ugFKL5DVtczGEEXHNiCRDXgu9rctMCblsyj8c7D51yrDzvIshwLxv6FyMqvUApszAohkcY8vQ319S5T6GkgVqiJCfp6fEMQlGBZdh17opSFmJ8thpZhMlPSf2QNALjDQJlXwk/Yc47uC0TzK8C2wiSN4InRc+diWIj13nqLhKo5AmJ3WYe7we53qH7fTl/AWcEbdU3Pf1fjt5qABahaJvoWKXcpRQmdhPaq2tSFVpJHVhJITDm10K+em6rS2zjGt7/E9aPO/wJT/uhENAa6j4wOi/2JnIb8Xxp8lyW/nSoxjOn1dn1yhQ6diMeJWRf7O1T2SWUjNdARVTWhmHGi0PZjOt9z4uFsw+T5TkYak+ZILZBjmojdLCDGOCBVvIqta16jiSItN23h9LUPsGdfrR5mmLZVGoCdU/roVWkdDytnSFg8mnL0nq23FQcZSN2yboJXN1Oz7vaQZDT4p+xKVJmKdRbplv0wB+A4JcXiExspMNXN5JlWBLC3pNdw/dM5MeTdZSAivRHQYTVmW/BVX+iP7Zbsc5AC/vgGoOiV+ND3MZ3sOxjKTSvDvjPESRYAgRC4ItEI1PFibWMmpDgzpmtTdGWN2cR4RJyrrDo9nbqDk29tvptwBhdKdhE3vxz7SNVOlzIrmigUm9Qt/HfCMobAuOpicsla6PY5ObcWz4qVnTwvWhJqA+Be1RAFTo3WqSk7gznYXYaCgstMZMWnpyJj05re2hz/qWO8FZq/WmeLBjRFeJOhED8GYzbk1JHuohT7RSyewRyG42CS0okD7CQ9pvlTg2qX578oyUtviQTAjXeQbhUZkBOel6/A0w6rGP5rP7GvQgbIgG5kKKb3g274B7iXtjVDspOBTwBNpMa+NypmawlHgfcD8+HUN9AHiJyjFbEd8eeqAWZ9ffdbnEhs0ERpwRO3QIQ/hDz2px5IupSQ+eHEHEB8mRQokEhDW/CwGwhNhn4NE2hW41Kn3+Bc94NWh2ydOGb1YC3iD2bBLI75qHs306PfsDjkjMzZSyWC3Cw64BHOQkX5YKNczdw71Swg34TPyG0UJo4Mgdpi8pa9uUUj2G9zvT8o42K4/oUFy7sc9JEucX6V7gWfXc3cZKzqIeDit/D9R9RvSRIoAeoUs8R4YpDy+rQGYGGMXJCfSBenYH6m0T8F6t8MjNNlhWG9f/ZPfYuWvXO/AS9yxvxLTaLTt/NJu59G24hYZNnQ8XZYFXao8dNq3kMWpjpSbegO55UzeUuMqLWG3msJkIdyI/e5sLUkt+EIyPgVm6IT60HOoVa/AloT7Lt9UmRe5hzzudwkV6UzT0IDg8+iHLrnD7l7+baREYYeUUEfJzM2Ad9ipS6tZUYddcula90dFadLLfSuWNHOD/PdlO3EeJpgOnPcDOpcxOJwAgV2I0zbdHG1BUTsnGoDSgAmz7nRxbxINFoEM9MDMMjzmMFcs23WvjAEHrunsrEhlReD1DiZBp2O0rOyXHfQRG58UhQze5MJumZKCqxv97iT0/aIPIkMMBx05QiYJZKFt5ZGDcdR20bkZY2eSFm63cmdfVfgrTEQLZgfNmRtIfYUxAMOM71IQDslivRvIjah4Frbafk3QpXBBh66dHY85CysVg5xeDpuurndcUOPIHCi9tKYLjKBb0+JFlApHOS55RAoKVuUyesptJyAMRycL9e158+IVWiFOYaw8CmCkVO9Gu5A2m5lGcDOAwA93OugMJO9MpxU4nkNPk4ouPC5ZEzs7k2fX6k7uXk4lNMffmIvd/FgwMS4dTThemC8Lal9sytaPmXjt7MaD76+PC4W9CMqpO+Y/Y39frErc3bEuSObf7ygZRnZZpB2ROJrii+sHI4dYjJ+RYOFgz3CMXJyEZYvrFLw7xzb8WUj45QL/2U2tbiUmJ4cfQuwt7VI+NmYwylD6hRN9vnaapLXWID18AMfX49VIgzz/7wkwC1I0mvaxnO0KiT4Xux3iSSf8ZlgB1DAMzkwXXaUYjo/5ejcqucu6rRPCkJ6ZiNe4A6koXHhhyrEa8C3Q9IOCew5ZvcVRlKZCbzxyU/2EhAbdoQ8nAlPf8M0c302xLxlIun89LCBrLr8mKZKMIll5K6a0S2FHFT2JnR6YaZpQS/hXXnoSrjrVYcrXnB47qtCsTW99nJK+s/CP03xt7OWAP75ruXMLS/0K95NsLPUSrJJFKCRarmBG2KSB5uCqaxy3prh1eCLFrOciQfMvM8WKkVnZOY+K+pT/OeGFDr0gzekHFtDuMLlCeVluI14xc+0eeWjSMwS7G7H35jEBZqo1K/0MQ+mLuDwU9FLmx+giKve+wbXTMc1BzIBj9saez7YO32ySo/nE7V3v8aHy45QDbGUR7to6RWz1dOGeRooP5U+DYCZpwzGtQ9CZEV2lZIfRKZgp4X0MP/AtDpaD7GKfFc1esVRWDjlYQ9o02+pONed41EXov5X4Ke6byPGWWpW5p2By780XDwzzG982o3nf7FDrUG26YZIZj3qXLJCjEqibzLW04mpQYf/hPjb8ZEtfMywohGVc9qOtxDumpKgiV/PI1Eh3iTZ9ssZSH6aKrJFlJKjPU6F9cwXbyS8Qrv3Eu83bbaNoFdb9bo6VYR/qT/VZR4if5RULA3DIqg8D3Tdf7CHoLpMReTK/oqVu7D2jV95Ja2/sEYTlzluS0ZDitwYiOzTM67c1kD7eDj2wgQXtZhviEI4ijootPeDmxppDBd+Uzd9QwRs8CPwamLoij7RwBGOFObIRgYuHapShd4yykbmtHzbCF0zzlyQNInVd8ethWfwrPHBQapac/RNd1mF2hJPAOE5Vq7+TKx1bpfFjLpV59q2zq6xNgQWrMaprSuTqu1GqZaaIgM9/c8fcR/QgtxuD5NybZ3TZ2hGE0Wr43vjWE4iyOhkt9BSAw6C0inyzqV5PK7ER02SRoW503A5KveuUI2OhMNTqV/YL5hT6wBeSZ8yINHQbmlGgfhS2+VQ46LJ4I97PR3RyVtgwmeEYLijfc9FD5PNza0C/Emm6STEVssc5CdB+9tzmXPPYymDMGjKAADiORnsJCppdg4laBcq/F1W8c/3rI1+UZToBCe43sNmfP9PgccZ8gpG+UbBzeTURXcIpxzg9jRbkNzDI2Muwj+fJo6uCT/La4GyySoyAq+Pca2udTWgTyC2gmmpcpzB/jGWrZXW8St3ZQcuW7IXqQBpNaL5xMyDO+nS3r0Enfc931XR0Gu4FhnmBULWGc+mLgkBByDzZoAxRkqQCuPgZPP85CpGfmerQQo/5Synfq2dq1gmqoj7Sl6lk/57wPnOYrkf4wCSU7Klw5eBFk0PNhcFEpdF5WnTM0Oo0vNVqyPxL957yGGfle3Hxwq5avqppuwkKd0Bsq3R7avVOU0IdCdH/GUPQUrbXUp3pdMxg2dNyxf2TWZRZVPDxoAL6a/HC9lTUsIG9ECF9MtgD9rnqFSHAtNpmrLs6SuO3MwceaGyc6a7IleM9pO3fNv2WMOBoHzXwYmNJG7Q1GWPYFhWOvEvB1T6auDlU5Nt4abNDVxngaDPg4rX9X1KHai8fJkyWYBR6YtF6ll3bwHKlZtA2IMOXKWi+srdj2SXWQrXjEdQrQQwQN6PPJNNIe++PwLjZiYsoMfBjKMYozTwu/q05W1TgpOTSn0Y1HlJs8mIyGAIGReH3OLvmgtHTmA0lVAyYZpFTQdUCZSsDrZi7xNAflhKktatiquu22AYNAQZ4FHLWoSzCCQtpVzs8pPVoL/OFdfNiC7lR+U1ZLQ87tjIQ+ZgSGlHorkD4I7tgO/tEEeX9iS73Izrd62vxalbpFqfheofbSUkwlp3ol5l9EFhMCcjWI80kV30o70DWF6hUJzItdfBZrE/dAv/vfKeo8iPk7qGHKIR/5BdQMDfzOfGYLemxejPlzBMFXLrCbTI0SFBSX1Y++3YoqdKq/nmIzWf8gcEFwXi339/MfqaYTXM4422Psld1wCLcP+WoKm7PbV7pdGV6aCyeQmpXmhph4HCu0P+YUBYfwmonvdhBdcXwt3V0JtkJQOmsg5Os4eNob1/aIg7qqxxRd20tbPoYud/QggQAfFcuwMxSA1xhtCfKQsfR2zPYbpTniKr2awHnrdxIeFkn2gnpKLp9UULG9MXtW0KUYmExbBk2v1FU4tAxLdGTzFNZBf+FIujandFrewYpc3XxCmAP6LDJ/cE3p5F0Youau96rFrX+q+TajygM54cgVW5iyS2+YqwoZM4BEe4M5MrAz7Tc7e0LiRWI96ExTiAxwBv9rpeUc/zIw53e2arPMNoNxZJNCFnyRpncvktmSihPtBteDgbR3E1c52PIVwy3fRQOn580BOVIFwsosDicOit1+Hwn3sUiEN/5QTrVX6ZXzne+oNH9Xk9t06raDJt6IfwDfpfN9TGC3VpCMEymLOEpGZNvmKhKXc3mzBjf1MomXbEAcEQ/dIrTXQZaT3dgEuztNcsqNihiYRw7eZCVuFsyJPdihVt4jj9h44NIm+vlHYF7BDLroSlbDjAc7kXVKNVhaiJl8MKEL7HnJ23A7HOOzU+CfEpLxBGXCg8B/ZYFtSCkEZu6sS797YCgluGOwsI9RjebA1jLZbTpUZskeBDEp9hvs4kBI4PXewxvRnRMeYyZKaVB3B0Dwlw8xK8+bXdPWFakd5YVqaXCE7SyTTKyCqYehHeNLOBl9gyq5qYFBWqgwYQ+XkwgMtZ+wyqcEgcrRoqJNqZhz1lw4Feczpn7vx15CmLJWcCl3IbOls8zid7HCE2URYQc/59DXpVCXKXB5683dd3kT+5P1n7sw+NOHc9yQ7MO8TtO3Lc2Dv3zQkCjTskWIkTHlcpt0V0JfIVPZ+OYqp+APQjP6UB8aFPXbQu2wKhfyJZJ3rIp1FdNesbMh0iXfKo0MYx6AyIXB8QZx8+vwSTY8KJ8Na7+aM2qdG9VP5MjzI4dShnYLyzxqyjvtXwIZWRqXjGu1uBsjs4ufJWbihaPgDAYSbsYxkS1jsQkGlzyb6YsBaK/uzdLia/ErM/wW7ojdYiHU7jeemlxdR24kspWD7chvXPU8/3TBg395C+V5wJ7jVURWZhLMrK3buBF7hVoirgIEzcIFLMCPuMSMIvni20SAc6gEYMJ7gTNwa7K/JRO5Os5jHFp/wctduTJauXMz3w+h7xKiaJc6b/K5u8nHxKsoH3C+G83SgMWRQm3Hi5MwzVOGNzPHj5aEKLCQu67IseFpLwXLOd0kRg2fM6J364V/IVOgkazsZr5WNMJhZAQ5/E6OFO9ZgynEhnOnxao0w8HWfG/q1PahdxFwlfn0uCODsb1nxCe1JbukEUIuit4EtrgrsPO8uwZ2DmXfeQHReA4C4aoznbmXZfjMVq2IjtMLWuam2DXi7rxYjbaSlimhFiULsTJRJqdNHunyhuiH7GfKgKAPivUVG/jefeT9qSwZJ5wVwx9QYRdsWKGiLRUcXSYHrGaFuCGGoaU9+lLf2CDcWweq6fIDaSDLmE8UW22Hw/d+blhVPou1xm6T1VfixGAdyNJwqPjcfVWlNJ+URscGJG2x0pb6tn/Cf6+DK69sjL8ZoCJRXk/qQ75ZkKJ6oNeqg5gelr4noDZUdM62ygjjdHYRwAb+7fcpq+ZGkECqhuUeT62TQr1aHF3cct1yOzCsPLRPin/4TKk95dT+FklOl7jtDg5/8vNv9AcpJJZAtH66fa8304KJyfZJiNMwSS8zvGHEpfcV4bnhFJaoF4f4rxirF5F83ro85tQit08nt8o261xoptmjn09wHt8pwhz/STyqvGSXdblX6X0UXyQB4YuKiHO5FamCCb8bmhJXQP1ljinPqDj5Fy4z/pODwuDr6s5m3NNOpBPb2KfFUPOL6+QU3da8pPhjcP+Cqu4hYTmrK+vzYdmNmmkt8usf+YlIGaiXgJ992vTg3lQ8ZeIvsKPHQYEoTrfLsM6n77PftPOyAwbho95xz4MpHmTRrZFqh/UH8l6NrL3S5ssq9zdg5I3zFYEaS+rPmVo8dFbfycUm6PKi28NLnHucDmVtB9R8ZRmQRLMcsV3qoJmJ+kmfmZfSi6KyjKahnP8yf+0JHaMmK2HrrQ9O9XNoSjaulRRaJFKbdRenFc3LsFoYiHSa6GPKTM6GCTBn3uVJBEssA7QM2Ap15+wqPSQuEy8cQ8oX322g50/Z+NH1Dl2qwx+Na+pNaHP5MrovjKCo+AYxZXnzCzegnVtI5iSEdfuXGIL78FCVZ6jwydkpjREU/YUB74/cIRkKfaYaS63WmPI4jHSnr2nOaU5Chl23AwaDjLOSNa7A7AHkqgbFinOmx+Xi6AxkWcv+f5rOWGPecbrA/lCtr6GyW9dn15NbaJ1KK6sRgTS2OwhasSmBHBS5XkR0Cjx56pDQuMI+1zo5B8dso7xkJ01/UC5udPNpdfgZiMoaIjNhs0Un4jQL8SiyVo6LwrwZDOltByrfA+Ts7Ek+LnbjAbFxYkCd0nGRX7SMiJMJDGXFS1eJFEwpOHWnofC3bzHDhnaioyeazqm7Z8NNxSgQiTY4OhCd+EC1ff0w0Inf1iRR4fhchWX/PyemXwmotFW48xGwvUDJ9V+xue9O+DkYnTW4BG5NlHI9Tb6gL3MEBuRTBDFvl0qlesTyiXyFdsxngdiFy/4oxfpewe5ffjTTi5EADtys8lElOIkMHkzmyXnRFYxOAlekwWpwU+AOME8YZqdYpWobSjZKv83QNN1leGj626l5bb6ElWpdlRW+qWpAznhRXpKtkXJiGGQ5IYTpJF17yyJORxH1z4fz/wkzRqLULYcWIpwDL6EjSh/nVXCEjX2wnMCpOwvK2DhCG/d/HMM5cbN78lhp6sXniWqhOfksv1G4lNdkT4TrzfHzW1+GT1X68QR5Y4ROfuspVejOHrOoHnVRDPVdNyCNkM9PDyxxT8vFMuyIPyCC/l4PGDq/qJ+5eKBedTDS9IFUXT5Gu5dkMFb/VGTdpF0NfPgeB7rKD/rSrxBiBRpTyqs3Hnpiu3LTKG2K05TL+Q7zKpdIG74ckxZz4L05gWvS38+bHY7las2YUgZDyzRnHCEVvAna/T+zSec+8ieeSWiUMRf3MI9m3li2mcR4ViKjbYLH3ivHlAF2QKHLJ4kTLxEFU6bSfgdboxPcskARfVniwhi47HvRmQr3NLklw0ihu4Xg7dCBoi3q+cHUQKwan5+REuHXbdZ/K7A+9maOpGvvmN9RzZwr6xDaAMla3eJPMww5jwypp7HxgujNoho6tlgThB2QIEOWHra2JrMl4zNWpxKwHom7DNp4IYTZrBxttzBLmnv2yG0Gab8PhEMaAg98t6AzXoyjj/T32tTe03H1HXyV2UNRMJZ8rke1CrJ3XlE2TAPTiulf/e0Zd1dbCLawwlmvCwcfj55V/cBN970i0DGtZ+uq1n6clUs16EGV9DngP8+Bn/qWYkc8Ixr47pGemI5KXTB1fzDZaMhVWTleQgjUxzNza1kAPBpt+zfyZ/0kzzsOc167IEzI5uICQVMk2futEMQ1VH0cBMR40mR7cG4vJgVcSwgExStrHzWb9Zp9qMeh1bAZHSFpzZ9bcvA6gJWmyqTDUwhq08wJofFlsGM+vck3Mh4FyMIs3GlX7ikcuSMZhVtgVInKttiYYmxqRywxSJMvIZjl0zVLuHQ33wTveuNKgyw5OAPwM2yc+ash2zS1ctmaH3fiMY1Q1Ol+ux3qZE2d2kpoSSKN3eXcBS8SdhJR83JiH8eS6jYv52WATEq2yAU4QuYZ/N5Rwq6vr+RkhK+GcIXismojQvP3czgmCVPi3IVvaNdppNcxG6OKWto3P+L8tdNp1e9V2+Of/D39oCn5aAPmbAgNwNc/KBfLOkcYhr61TMGXmKaLEZD7fIuLl4/M8lAbN8w3oYX64y7c/eIYu6P3S5TmDHSIgD43mDMZc+GwjsFpKe7NnNt+E2WFNLeG8VbQSHpJecoq6KnG/37L8CH4u1SVPqtPr6NVHnO1FGJ9fvZ2zRfoXCY0QjQz8CV+cS2qs2OrvzjgZdKimGX0GU/ZlPUsCc+MlcoySG0f6y46KbOF54chmmyEqpmaxMwXioKIWtaWQa1g1XGUDnSrb/18J5IdXNhp3tp4W0AbdnN3jAzVq8EMdKJ8zae0BPCWtiziesTpYh9vXkQqJqn8L0edYJzx1JF6S5ekAlNWu8VBABkaSel7MEZ7OVQJfYBEWhFY2xOssb+ltMwLjxO2kw3ECqbHL2C5spAHKoN1A2Yw/Zl2CDts7qFLguuoK0KaxnAKme1BXu+aqacfZG7eOgZJEnkOeQYdyAjQp5vRzSJxv38OFfpZo7nMQjMn9Gc4/z/mXjibLNJ/iST18T7YnRkS/31t0RhzJ6g1l26sbqPPUX2NPBoRwTTybmaVYzFtV9ghwocXlpUWZpE3gWdpAlSHtwpcUzn/RKm++5ZXnmjiV7ggjmevS4vjV3FQt1NDz2l5aMU4g38JkgUmFbrziCL2nRgtiv5LilmfKslE7YusCsEUyCvC7XdeIRW5XoolHxajkLffi/mU9VAXMl2hpUgx/NlE88t5Qj4uCSpNRFNkd67Gqbg1Via8KkPsjQrrBsZkG251qySGiJRl8yekZiHE627tKaCPUMo4e8szwqs6pgbbAkf/MMp5L4yRo1IEP/NgAnNU+5jP8kLX1mtAPb0bIn6y4rrEukHt6efwdR2veIo+04itcwEdFd2qjc4Mwcq0xgS3GkOk8RpwknqnnGKBsxaI43jdaILoxZzjA1M6kt4qch+WwUq1wJVODqW3Q5WCb+dYUhapubvC6wjHkvxqxqNAwSklLRUzH5vsxt07OBuEdHqsUV2gDOoUyac0UWewtC48OhioMnyCVJ9iTVAio1wQE6UtoaVZPxsqUEwMGn89YyHCeO0twptXyCrU48RCORX1Xk93NQRdhU6QZmCJvc+ZswCNp9WTn1Pogc0/44VJojj+3avfdfnRxlfXKhvdhZ6OzQaRthTvRY23uEXHckMGY3URjcKjs0TMxYhGgy67VIib1dhasdldUSG0flbi8J1GCLIq9aMxFL+Os26+xk+ZrrUDraFW7i3DFo7SywelH3+r8T4LOlc8jxw+QKbsytV6eTVLAThQ5pVTkMfAUggQwa0KASZVUazGSdG+iBZA3p8qa3KHKr9jIfkpnTOG7iW6l99RYzMLu+/TNVqMbIP44ujLbCQtWoHtEExovAcDGtPf826cl0tqE2WDEFjk6nKOXr4hbGWGv0cYXV75oHhqxpogp389vvZTFBPjAOE9ilzNxO5frWKS1msNRCP8cqxbkokf1HVSGx9J3UNtMYWR1Q3Y1kYywf2YKEjZ7YHHkVbmXstFucJnVQS+6yDC5MaN8weEMZ5r4GOrSAwjVgqI2u5yWoZNlps6MrRDRTlINLViF2Nk9JqJmm2moM1uVGoZLgh1pAMgGAKV1hYbY02S8OY9arzO9UnKK1keIvvJBLI4zrwZAfLc3b2B1IpsqKna2ASJywkt2lXIMHt2sB/IfTfCXuHzxAb+d9DlAdO8y0PwgFQmmAUDhIY1d/xtBhxmZCvSfbLkpLMhIRx4eadA7wmWi42GCL1QrZCAGIFlfR4iFNYPNPEKo3/q+E9HXaoGIJqP8jKP6WTRmw0voJh0yIM7BHCWHzDPl+kqgPtQcjNl7BzrPATII4AM2yDlGX2nynWc4VjqgluNOJVjzUJg7IXsWsTrBziMsjv0sskotCZK51YfWgZ5OcxHS3hDR/nz1ot+10lsxHlVWmLSlaehGT9ph9/6sxwbAjwlOzf9UExDbIA9h6RhsHR0eZtBNeXzVL+9e9XcmDWIR48alrIcGZ7H05nItSL0zqr22YffuP9VrWx/MBVE9JR9m+WYq43o5I24hkREbO3mIhikP2wpAGM0FcF+4bzDK5HxuLWKL5l67C0TaJw/6OETm/Er+dLB2P3Aj1RnvELjROhb6+nYPysmzigCpprj116MoTlyp0dMQfOrSlIx38kSO32DQGm3duT1H/3035c1e8HtkpNPrEe+tR2uewKsC8OCpPRDdfnGptFHBbNzANRXPlOaatqnIKQ1Rws+JYqdAWnr8dRGPr121F8hBJBj6gJHVvtM6qWD1l73M+da12jmBAjU0xZSdj4dU5qEGXl16+LQN8d5+ESHUW5h2Ja5k7lSzw8nyZ6kZCygTJUahGWPw+ucolJoqrVBl6ivvfbUZjk6iFMcY9DLmHXz53e48oYgS93nzT//DFEEpqE28xG3lHIf98zAkHnElMFcbCatXHJtcCL07PNf4IN7DFzLIXdCoZhQlQxJ/UNc6W3TEUljjzSpZWYrVVBtv8ZQ6vrWadenSOvFvBM/TGRKYyGhZcZQy1HkcCpU/0HXHwh+n70smJBrSFyU4QONZewJbekoU3UDM5y1fzAX4liYx0QHnE8+mkhKiJfoe0Ww7n0amOzD4qebdFUNqzuqiO1gBp8MtpEmesgEBkXndH2FTf6bXZnNSb1YiJX1cPPhYOMnci+uRBSJaEY2zeMb7vxrzeftiXU4Sf6e1ks4CUz+d4PmO3n1fUjLmnmaQvIhOcFveHGRf/MeI8+Nr1lg/rOBBoTKfvuRdIiOoiFbp2S8sxYVdbK5Lo06ZpugGF18pcZl3c0daiLwBGXRnNUlk4AJA6+ecBZ5lPMmLSYCE3f1FZKYh8DgxSyjDPJfFoyAN2nLQtP6IJAI+xijCv10EAtN5yKNASJX5bOyY3H/Pq/vhHI8W4o63bTVyIWYE7yFUgNEApqVUSrOViRYWnG6sHT01lhIJBvo92IdyUIxOpj8Q58LUNo/1OUJPD/I23LfBWd1uPLPkA4bE5JDyv9kuHEf1bPCyaCx/wN+bw5qoHaeNHzWamZ65BsrwtnLS0cOzfobE+PFGtyKI2080g24cpDkP2xsLQOkH0uU70OvCxTk/mP2XaCWtmUxsdm3qy2zz1rLTKURmvE0N2EFTnqdSxqlxy+ROQy09HUPo1ZyFxDSH6EGwsuBESHU7r0nhh23pjZwPcyh682jyJvHha4KTvEjyd7TbDTqgjbzeOS/VkGO44gOu+t3wcwaFlMdX2Dm0JipD4tq6+ArKLQ8Ylcet8/shFUVVBZR2TqOxuPbPeOhk5PY2xlt5o+GhfuM6n6RgfHljAyrQ9yDaUZJUDc4L2tTFD12si58QmwCcTwW9+N2Nl3TCei97VeSuoHcyBcl8zBV8D2lhikrpcyTEJnaUwvkVt8ULmwiLtEkISWt2NjNSnI5ysMPbnGkjfzrucUg29Cl2mLtOi799yt3wihMxpaQ453cbY2Txqjbv48yAbIkjFdjzCAHytlkrXUDqiZfqFE7lQVcvmR5gyo7bAEeYGQ5eR5dC1DNAsj/YOBS+JgzU88W0yAhB0M9PHKEW2SO9sdVfIJNIAhvuIa5UlnBlCVvOIhZJLZYuEhrB+Xm6ydwoC0Nx8iFpDKxF9vyPyLyWPEqrGcAbv9sIC3Yk7qb6byBT/qaMfHrC8+o4Q1oaTcRuBclQ7mmtNVt4WYhJMN/1g4jNGwzP7PGsJQO70Spthd4r3nnZh8JytA/9rsdOP3+xqxpRLD5/GOz2HYjs21dIQIGg3/mHjjAxh46EZvmttIocQIZS0tWbTi34H+jCR/WHA8tdQi5X6nUwy+MSbEElEA+oj8KHVe9z4bJT9kLAUA1ihWfchyDsRPN9zxcT3hTZ5eZcq7A4pQoxg1NPq6ksCpVul5evvIf3g1R+UVe6wFHwTQDV35V3jtc+tuoloREoo82ckSHwX5d7NwnPZ8ueK0JttJ9Lwq2lt3JOu89D9dQEY1yPalYywTfPtTHjBp0fRuIpp4tWePFCkp0Y683+wUTOr4p1wh9DiOL3EFsEYtJKpSjZFvIROrgaQB0u1em7C9fwlSwzKeVIO4wJPSey9OiiyarR+msIZ/JcMee/QUe8tncM8KgOscA6vO311+AJejpr8nDMfp+qjksTtYxjRHaEg4FL0lrwNyk3qTN7TkBJ7+EYuaFnAYOy7LboeaqUvS3QDg0SOZ3D4cbcWASoBLWNLW+0iQStTD/bp0uQuMko9mht89dzudT4oG7OwoThkK5NAb3Vu+cTKF0aH/sLfnn989E+sfEZvETSWt5ku0FNQXaNcZI9upmjvaDC5gT4iZVXtS1xK1QEg6SO/NeLyciyxUGS6e0k3as12MtQmvOfHQFHgBzvLcQF4EqNLZu6pSutqk/0amirR27r6Ybfa0q2Sjdrn/FeM95uDofrafPQf7suyYDf78xo3rqSntxOQngXTB4ZCmoQVYmvtw9FjhYRFHsHiwMWrvPvJoLQcsjiSG3L+Xvmh81WQ6vD4HcDksqexcAfytqa4YqQRlUBgbSh6UZmPiwLvUQ0CjLkQJ0gUyrUSpCu2kTqs17dVIy1H/bWAdCEJdzk5vwwrcd6wCy02A3CejCvwxGOKd1VgtGwZa+TdA2SHefn4/ov0iMZFmzNtIXREA3fvyhpFkKh/6bnRVlC0wy9SRHW2miEk6av4xQZ33LYFS42Vo38BLFLrDQfTqkiO2xI7Tnkxre0wHL1scxJPHHiCSUG0aHEU5yqlJypFSGENoJnJoR56A0pqZ2nV5bviy4I/JfVNl6YVwPUWq/l2fyA65eCdUnK/RIPGc44ixgjtszv6YdWic/dpVesQEVY33z+S2vKU3/N1ReFtmFDN/XkgjJVWZpO5ixZA+fGOhvGFdQU+oDyhBsEycKTfqO0jvLW3/2i6Di90Q+ApzV2xXeTQmox4uFwlBxv7ShpRRZV0dUiaEqvB9rDBkgz8b32hvnNtRv5uF8IHC5PRt5mS4A+oLswu+FzYKMOC0vqm2kutmTbFRcVtZn/mCvgu7XBRBRRyeziFgnyhbbi6a6X4fagVb5wCAjAaNx6YTGLtAi2pTFvR8DUbkGWn4gIt1lHoEEgmc1OnhY1SIqgh4AFW0px6lok0LJu/uB5VYfxunEeljimprhRAjHjzgJVBDiw5vwLuUV996OFl68/wBerDHCZE5Vv91z/TKjsB83SujnSjXWMaglDE33M+IXCkaZbuKjt/loYIwc7kZt57LPI7xRolnm0XrT8yNvPjFXWBDJWkXsq7GARlS0qTHtY5TVoAY2d+8RO9bQsohgDVutr7BaOq3+1W071Mzm9EPO3QcMCDZ3aC2diziK+HA10v42bLFOGZ6wzX15McxR1m3qktP6H2gd0fqPR5i1bta0/nihlLHujQMHgqYiXIPswfUzdnDUOaQpEDOyLitczlUT8zg6jzuLvG9aS11dlfsSBfjw3S114FoQ0lCnbHwAlwJoy2f4ezlcv8yRj1gjIY8dLxpEML0baadwTyLBp9y+4p2H69kRMs/KBvrSvXgDO1aetb/VmeuqxqzcUPu9y8ExhmzjY3Az0b13+EO6AZC6qim6a+BtMy4rl07SrS9kk9skxhr+0LKmjekFW5VddemfgTirz72r1HTQvv86xmJjUSsUkCUvOvgwdCbADUHAS1o4zRYM+a3nU7V+xW5GLJPFX4sNDjMxs7e89N30RKtbj+VCCBzF6t2R8YGz/BrWpH3tVLFnJWJdlvzFAINkGCsAaoTvJUcUlIfVZh+Pmd59cgni1lxDcLKoSokcbzpDcXKrY8IDLqfqbCkJtqFi0vlhm5msgKIVRAbk9t5OpTEy9A4wtw71kTLM0um2ms8uRG/unF+oFqWROMMNHTkgUWT57i6zor1VHKXdQZzcRXT+26841EG6wnC38A6IVCKQVv3izReJZJuSFGv8NxWaYNbaMiG6C2VEvR2a3N9TGV0+JnCQ9vlm/3oTxZCBx0OXsOo8Iq3RtmqEalE/dfEkwuR3ObjEMrJknikYlk1yiIyMKTDMKe4Yw87oE2zjrj6Fwj68lxnL7YZhFE2KT+BeelgEh4JcsYuj8jDoFadL6svPoq76KUqR+BVUhGbka1+g1wBEtS7GoJ7FuwknKinfpwQT6QbB/uR6X/BczBHnvapigLCXx7HBd14ck353yE7AhYWgWGB0H4dYaoMUQE4dWSvqaa8wxQfGl1TUvPX+3uLRPqTM82KWN3YTW774A9Thf67980g5bVgDMDtoR8k4WRohk+GWBdgfgXhh+cGlWRZO+vg4jwISJpff5cocSzSZw7LdL4+DOtIrAR05GZ8JAub4cR7o415w98j2oT79yQH3dOt7b9GaA1r2zbFTVIbR/sz+rGhwyZleN4r2YmLObaQ1p9t7SqRJnGZeXVEET7gFivSl1NyFp9eBDsleHUf2+9ysYy5OX7b1nmkqiz6iw1V8qcnuZm/BiP8H5SbomiP+k2Ltg9hzELF67RT47mOFqfqZk3Mjz/M0A9lwuSUfSwBXw3WxhUT+wOi1uLR0e0sz5yvj+uaC9tGzdtkj3MYUdMdfGTLm/kiRol46DRzZrtegkYR9PzMlHR0M8WP2wnvzMauzjZMFlrnnawTDiUP7aRkK/Zz75nMBKuOAV2ZAcbihkPfsSSaGD3Zna4Sj+QQQQ7Og3s+uizzu/igcYTrRfi/gXtAegQn9WhPmTP5hZ830bZlKNNQQvOo8NpVGnrYLRmyHnZaB3+o8sVx1xlDyw0Ym0P9rf9HItkCLIulK8S2BRdgL4U8XGiRBHQe+XzBgmL5NpPtLi1egEh7Zr5Q6X7gwWQCl9o9j1EG1VPzDzGvv8tBeK8luerRr4sPu5hou6+Az/DV3IFAmH9Sx99+hYb2mNhgfQXtk/B1z5NONM4npfYwGGOQy4iUER5oL2QR0bRFbWCiiUXgYlK8c9Jp1gH9Fim5YQBaBVarVv0vgnDsjnxucjU2daUkEBPcdy2scAL3Eow1HCLynAC60AIft+d0jo0Eve53Jk8vv5CwVgfUJiAppH33viJU4UTDcZSJ3rseVJD6OiwumTVzi8bLIMDjKghqNZC7av25XBHtGEO5ANqe2GBFxcKc9TgCJj1xOjbsmtfO/pNU/1i5fYf+EOWPJMlfdGV9+zVp/xb7XZ0KqZWx/nCEBOfD7VyXHloVu+DSSqUm4QJlY+2OhHmmRR9s+G0HOwb0I4UfDBdamoCb3jFNUmtx2j8HJKDIcIWzAXj9873mjcxr4xvUruhaFWdZbKD//gDV3EwoZzy3UCnqA0MXlizDSEu4o6o5TSxIB20B8Ovp8/nJP+g60al+hSdi2qLhMviCi4XaZ4BPfI2GwddpvqTsYHq4Ul2Od9LRYayJ73fJzwz89C1hjTi3hgRM1p6cILsVCtLKu97YQ/oLbIIDekNn/YxOQLzB0geMaadthDxvodk1dX7kwXJTwtgUqCO5sAcLDFB9AJ3rrWi2fxd0I/CJ+dW3J/cMF7vlI2TFD0hknQEg8Byum6lh/hBAwuehG5l6vsC6a9kAUHjt2PHN283+w5bFrd7tTamiSGnMJhPUOmec8m+Johps+TPo7DAtDLlb7RQ/aMUPDxyjReSVPDiJ/mMTIlGnNbqFGaVYOHPFyumhucp7uZdKhH/cI3S3thtOicLiXicavAYcxznVSL8obKxdC0pRJ5ADtCT6pF4oKFu8M+6CPrdzYbyvXklohu5liiCiccoo1M7IJHk/s6eeRkEhLaoem2K/UTuazxJWGrIdjU7wKq+YdguvZdD6CCBs2q8LnonlsE1D9Jgg2xJkFMLBDQiGD+UxyTM0jfNFHAYichkWH+J/xLB8+GDtvm4q7m4PC/1J02I1U8MhhUOqqx44SAjWwIhVQSJ229tn16BnQ1E3j0jB4hXUs1fWR/ss0L8uC7AJPjSVBqblDRKWjLd2a+UJv+/851NJTfWTOQnOLHvdui0VtaFoVMmzF8kyzADHpgDp8iM50JEnoyEMULRStZwA7bNMJRLIzTAY6jjeW4C52/byeN95SukKHkZMXv91BbXYAibNoHBaZhTEy5bnDkvmUJMTQ/uYnX1KCZHYQ7r27QX3B5Z/61sU8CU5SxasCjboImWr+yqcgtbvyJDT7V54C3V1Bfm47Nb1D/sdJqjbvrkkJ815K6LFavifJIpl0EizzS3DWmTQQCVGSINgqc0tyF+87JLoKykbONwJrla2bNQD3uj25ccATt7KSkkD6Atqwt790f8YKuokZSjbgaLav7QBZrbJHoxOBQ+twzSEZujEXpvaQ8Mmb7ut0LC2rJvvjbImKfcGi3Dk2BYh1iu+XRwHeuhrZpHU9IsTkeRfepWfKoNELxOIhGT8rWC43UgHL9rF2YipCRGKjjaSI9AspmfW9H69Pp1LK0HrQT0pCdlBl2dprWxrhMvch0MABwJhpdJzPVsSBUx/LRZMVaJks0hQxVL8UEuFCrlw6GQj8G6zc22KWTROrxKqCWz9uP3HvbCo4A064RicSUtGnzZNb3x/Lst+6ZNckqD1bpolg1zxNHsqn++wfZwwCesd07i/1bDMK51FrkHRWzRSB/ZKpuOWLDG6M7pEWhhTkasFathdZESSgrMqTLhY0+RidOAsdsKrjv0xUfCOuBXDU+wIUx4DQ1HLwhi9eFHE5BzPirUUXP5ue76TiBPpLmdoBmjoh4I7y2JgedqTDSH0PlZ5g7Vg7lGz8DurnIymqlVD2FwO4TMAYFSJId26XLT5JjPZldscZKJcBZUjyUtPe9+VUJA3sTj4+qpkK+NE0y8fHC6cj9HJH9XBD4N1wfO160KPGg/CHF4Io4YZTGW1GaVYwXBIGi3htucXtW0DRXQXS8wyuCZE2+Uf/WMYtrKzgI/dKUG0m1vxqT7e01sOfLgo89fEYcP6QGXdomNXqyHrjw09F4TROJcByeLwvqxNVHJiuuC+WOfIDSLCUcrKsVnJ/u6zRtqG65Os/hnCpT0Vbz4pdLBYH2UIo/2jXIbqc3Gg9hehuxV1vdcmNPIyEqYV1OI1V4kA4ab4TmgV5KOGsuS/f5xxtyx5T0C45Cp2tbWnDD4Fwp58b4SGZ5PEn0sEziJb/BOuc71ZCw/xLsZ55TiQX1QFcc+IAHYpzjVh0Mg054TKW80hq/xfHTCOhTFM0aaBbmdgM0x9e4mY9Qtt6NZiT1DeHiq3OOelblspRcrOJyzgzDj9On6uYsVe5iRwqemzF7SbbhtzDo9bxnbAEnxrhlDsIBWgpPmAuYNpcT8l3gxdmCr+FsPUfIeUYduv2PXqfq4NEuObdEV3+PxJEY415gR0v2axNIijf9v92xCAVWkOr7Fd5/Ym8ozmgjRnRwEQtnEXca3vtgZT2mr7326mNDbY2e/oiYo8ZvuO38r121kkyZUl3mll5UF9xJ7Xa6ckXRh+KraFTgK/7G+VvoHp4pOeqHEHnzvzS7vdrpVHsncZmAYH5NBc9BObIF+6AmZchYR3x4tgunQG3/y1ksn09r2iObtbjJ7VLhVMB+tExZTfDOHlXJTsCaRanu0S8oCv8eAjxW1xO4+mgt5Lj0VHzuA0jk2k3HfTZnwWgHAPmV0xYZ+jz+fjMkIlPG9af2LjvmN9REf9K5dpgevKvi5BQYJHKbVifQa0cDuQh4L/SyA6cMOk4feyHMbKAxWlofqLE4iZBMnG/xxEegTZiEL6fos2EMA9bJAXOnVudKhttEll6Y3oLucExyZYCurUujCuf/g+ILbAiivI0UeRm6oH2TruAFmiiqN1UuZiy+8fMGy2/oF/oaRR8kb+MNEfzQQUnfSXoIBHtbXzQtWGPUg1OL+WUV6Q0S7DR+ZdupSaCdAZ0XnvcQ+ac5jPJaa6S29wn8Sc8Nl+jBILt0FNaHn50tN/iCDZqqX1VNeZ5bV7rH4tXKM7aGN2Rq8oirbU7o37MNjCvT1zyQezQSVCNQF9z5kO0uvMwyBibSTeLTyUxEItRfjb9vYwxrHgvk+H2ZxC7AyuQX2RuNYjYumb2Km36MJBiqNLlde3F03X249jz/tq4RRDk3HnhzvJNPsI2+OH8+nun24ACyPMeD7g8S0Tnb+mWO+lGh/pGvbNb5igqqP4gVvHgJHTEHjRg39BlOKp2LkaRZKhxfQMVFF9CZS536iXbpTbl+E8WsdYPgVdB7dfL7pl2pHnqQGwXqx+Pg9eaMapPJ2w1pP4sseDq9F1OTvuBszJgrkDEPtPC+cPihaSFFuRP0JhCHBJ1xFkduZHvFwlx4/gvYOkwcIMw69b/AYD6eFxd7Qx44SUBU9UgOBBMEuwfJpodKSlSbh8cBAPJgDzEf2b0jrWUwpyqmnmh6QVW3NS9B6XOPvWKQxQsOY2Yupspv26zL/DN/3rq72zZ9uUXGHip0s9fyj7eYJo3gHmHk5944CnVhBnXtHXV+yKmCTXBlIBVjQeZzXsNTpBqlBS0127kf2LqeOeSblrhrK0q1S4A4qDZX/1skGKdX3bD+ljkMPkuIU05Uhm9rhtPHgmNgExkhriH8wvRAs8as8aeAgDIMU3gXXlgzaIysKjdImqNMATuB+eclYGjjnCX+KNek+eyUJojYT7JxeUh05128tCR2BuQ+Hym8UinRgp8WhAH6lhEINoER1im+HyB3kwO2Gg6IpEvvDpa/n+D+n3S4IwTEB3tSqYuVRcZtWbcVio+GjLc6uHoXSE1/l0RzAeRze9cefiwsPVIE0WdoR11JymXDnvQj3DtASkCa5B45FIkQD74pGF2F1OG9LUjWSKb5dmtpMn5NBXOc05JI+aKWK0zGLplUuIGHeABTzYE0/UBarWZOZ2IMk49S4iI+fkcAmsLNCUs/CdQIlonR/viJbDj3j2ABQGvTFMtc1y3+MkOzEKI7/oLow0zzU5ucziVz19Wo1ZDMpQR3E3KWBjFeIiYArBM4WXWYZO8E+su45pJQwQsscpYMv0Qzy7SQUxwEw9apvr15xEqpznOm1QcqGqptuWAEAht8sFvP/N2nUM3KiH/U0Rx8xOi06kFLmDKrzi7zNVwr8KZPD8+ilVVufnN/sVS7lVEIyCI90q/LDVcNdzBuN16+CFpvnPc6YBNN9+7VqdDwvVggEZy6ffRSkuUfaqHXgqIYeXACSduJZbLFDkH4h6/b/SMP2fi1H3hyyv0VMcXpsqtCjueC/jq9FNgrbbKIqH+nyssprRp6Deh7gFKF9uhuAoygjUh4fHLBpgu2o29vIfHQ5u8EtadVMUoyc+4abkXbNcphPNcNRyi6EVj26XQ+Dff78R46mPDJnmaQIY9QVrAVjKLZGmQT4GGtFcS/2xjKNhpe8Bh9AZAtuwwWSNrHPFatqG/5y+rdYqozHsqZ9zqdm2W7KHh5tyJgxMphB807y1q/ycreXCISbxgKlJanLFQW8S9j/7TKzQzDKGmnTznaAX01FuoF0hcTfua4lFr+L9PBGgyUE4gRnQw3tIy70AEhDzdVwVIdtwO6ECzeprJR+riYxH6U7Ncxy98s0RVEgijyxOZ/x2aU9qhM20CGYKS+nkmy/QUwZx6n1p1Rz/jgG6vY9lNNk0iFGmvE0z1Nz5R4jdYUHkOwDtxG0C/Acg/O9iEdr/jArc174QHjtqXyZzbDyn9PVyClCVacmV7HJ+Tw7b/K7p7GplGGo1nqs4HsB3zNwJMnw5HEFE2Wips7bTUBCTtLboV6Y/LTKFkcwY5M1x1/GIEmNRKjUAUgU4Ya+syLP7di/A1qJBHS06VQ1T6io6w5rAf7UUYXPsZ1NCuLtlKk9jGVB5xiE9B4l+/H9t4UTmXXseCPqEZ/yvuuXXbpgv341fguLUL5BywpS+k2EriUYzu3oCY5EvYsWd8j1YkUsMYqwLk8x6LlmUDlbZsuCWy5hfnA5NhV41Q2tMvY8wQ14vCWehhEMh9salVYK+V6pAIsuAw6gva4JvYu7xLtQEi0w8jg00/DELeQVx5uOjzphEYA7KPMWpcjNUSIAQeIYjDcoL51gtUNdRm6UH1cS8UJJfaVfp9+mTOFMErzWPXVMt/91ZpK37SRgywLsuhyKLnNXzwFoYezfLspgBl2gp5/GY5dKzsySeo74sASWl9LKdrOc9PLFRc2jIMMrmGx361oWfXaocvy1j5VCnNGj5t9+d0Owq4IPxtxiVQ6SY7JX5uHoUGhw4KddyXkzuMal+edy7WXf7l6Lknn+6p6z0+bsJd3vspscWwWPFiTc/qN9ge5SQUt0JyPKv1+KcClt8tJ3Sn73+irdMOiahc4QCxcvC7FEdiPUMKXaVW7I5+K6b8xkE/itnMFH0sgIhK4Pavvvaml1dNSLMCgu6yGIMTnp5oo6D0Kr6gpU2U0zp485sX+k+F8BIk3/ps6BPRtaoYTeTATvfTyEtl8lFlaWQ3svnociw0IAW8PWacOITz4nRhnp0aJR4WWn5Tt2+pivW1Fy8Nl5cRLIRjQL5kU9makNzZOAb2QP9tQTYijo30bwUCs7WYj75wKReEcPXYotb69B0TAkRTKwnZ2k6vQdb+2fg2GeRj20oSm7yye7//EZua5ht4cst4Po11LmoS1bnQiS5UOzCchH2XjwLrIHlr7bWAy701mjpMqgRY9usqDRPbRf1yYPuFAG8+CK9fR53NCHQTi1kx8XG/RWHgqEVW8e2CfFcubFx2IdG3aUz81+U7ts7TjUUHDIluMmG6LaoQZ7VabQFRY0UqC+FH5ZfZ3X3P23iRPqLvv0L8qRc+3BQTNvyyWFhtsaPk3/NRsBAZf4KKZplfJsg8GqJvS3zl9U+CUz5AV9z7M78ozautYSpiEKGe2RxHEwoZFKYkFEljMN0t75li4QjaH96NwOcDknkV7nSI0hla4JC+WK/ffr65j+vRgPJLQmlPO+kK0qTttqSBQ39/etO8MrHOLYBxh1OROvfho8N1QX6Yg9KdTDUBQdJWfrhM0f3v8ahd941BuiYOkneWS7Bbr/BfKWIyYvpJhI4Urg5XGiTycEIg3/mcBIKtD9qlLuRJ8PiRBv37R9frNDKunDyazKVxZQoI2fqxIBDX6fN/Tm5OarxIgcSEXjUTVcSwj5k618KCgX3twRwvyKE+NnqmSFvS4vUt/UzigsfxBHqAZ/zp2gXSRYrD30M61MGKzIV3V1d817HvaYrTEBomSMZ2lzw3ieZUreUfJk1tobdCD+znloY4RIiRygWUAEJnBF1WUFnPnrDc65yEu+DwqFiKj/JO3epLQgtg6sTZJjh1rS0DczNYXs/u2K4h5BvCwx2x8FVlKcpAzIqJK5TGguGd9MQHfPHXgaT6/clUgoI7bb4rKPP94DJ/KO+Mhi/rJT7JxM16F5dho0pLvZvLGRGZHkQEPv9N2Y5qMWmbDtQmXbae0UjwZ3OdbjM2jFZu7gDzHI5OhlRwYSOeYezKQwkwr3LHi7lUBXT2ZxUCxflM7sqK5ON6PHgENvK5SKnA5+E5ZKDT0WRZE204FbWNpXbsS0cnnRLWFlFfdzNANMUC5kH2REdShxD1jWM2484IKdhVwHPUvkd1OT2LiJBWXhZfQTRdyZ3PfPFfEle+mlSuiQ4EeT7HIDw8S6laJm2e70sjl23aaIhnOMmMNzbnmZrG3LUzlYKelzrIKU7yvAoqm1nc5nI+rGClz5QjAthXnrkjlCy4i1ftxHUP255lMelQybO/dHmjoxQ+9a3ZdjRC28dlM8fCNjKVbB8u4vTpO/6zKjokUa3BvLpvKS1+M7ggStwaDGetFpoKRtO08gaPdA6W0Nx+THiHBOaOo7zWA6sWywV+yTSn/OQNQxc97ZxkdCjv2L2SV53biD2xOd8hSACCJ4eIVfrd+i9wbKpg14rYtVGpVfuoRt0FzO8BgABFwBteEYueBQAav9BEhRs/2whhPHndXlqK4e8ZwzagczMw4UQUWoz92IqhT0n8BjPPMak0LcKiXR5yVL8IFmV/yFLvHyoJPRf7eJbDWQDsz11WqCnYvBDQHHFd8YIHNaWyhmo9wRAF64QXzqvL/g34plgfZj9Fdab8anT2GbpFRVknRycW6E0WPVZh/c2e/aF5kK52W8+ZT6QcNXkENpMp2sa2wkYCc1tt8iHXD2Wg9quE4Gq6nriHwFExNRNUWDKbjg97oeJOQ4uWrl/7vOhcS9tHA/Q0IcivcM0k5pRilZPnIZDewRl74SgSLswd01TAe9lXgTPgpaNZ7ijjJvH8sycTF1Bx+9UfgY7ghOKK/Jze0544ZijZ+gpfHcmRBAtNaeoc5sEOVMxuxIb9XlymEpAuP5wYf1dWmhDoRnZrECDi+9Sp+GDzpqqaY30h+eEREcccVxHURYtaqK70qmBKMmA3T4CUAzZwo1rZxfGzJkuyd5p3WOrNwGVp8lMkQUiAd8GXaM4ildJkRxUPtMT+INfYrc/g9YexKmHcOHsASCTHPO+peLnw57F4YWwN6UgQZ1hMVyfcAp/zgQPbHBkcHhWp0yXm4HMu2fbByVd3jOG1H/eN5AWMb1Zp09f27hvH557S/XvqxygVZqwDdJ2Utbi8LV01vJDugXkz9D/kaXZkXxKq9PCkveZFe98UV2OxcqRf/kULnJK83+0JNJUANFVrOVoy9A9zV13Uq+n3RMkEgeaXE+x/LD0xYvoUD9UZn3WHlXcibpVGsegmuVrG6o9Gvr9M417XnmalZLQ1YZY/RbWXu8xcFTMGvC6KQVMiyxKT1vCVCDyj/RBI0LKLDV34cx1jdbQ4d0VXr8I/5QiHTjEe4O6d5BfEw0uKC5SCkCFkh3lrB28jJ7+uTOczeFWnTt22UHf+pHAKlbrmXiHDQ0BkZKaFeX90UxgTTEUME0UMm3qK0BP7cdCSUKHQ9xmghdmqjiHp1edUw+Hkb2nyZB/WMS7Sio1PSsgmGie6Kf93exd8mvxSrBD9ixzKY+KbMCUDQP1S/uwaOJnmf1dcDJADH9kTa5XxikbYcXoqJDlf2PMBPmnoFWhG0keined2Lb4sglPmdAxxOmKjjP5UNCvOLbAeL/1JbM12ZYy1t8lBdcLJVRyb1ynrAICI7g4aXLt7AdvgS38o02h6wzzZuvbX8wFXcmtRtPkuF57PGauBiZ9H2PBqR28xBRjawik2BF0SWDuHht1Q1RheqQ6rG3qo2B07IEhGLCsfxTvcMUm+MDYd8NA+VI9G43EnfXyV/2PM7GBmeOEac07wa7ZxXtnMgs9OLMsaYI4C7ze0BS1nqtQIfQKeXlMuuJI5WIDlCiRndccJKiVHHIbDYYhq2NtvIABKWHIT+O/f+DcdjILDHwmmf3yHRblGJlq8U5CVjWwei+1bBnou3sPUe6GnW9nveZhidETMAOVpNYLbU0ec+8zJvsEQghL9o2eahKZrg7jbRhLo2qPye1jITeFDTe1AH/BVLbYbcB7kpTmXungDrTHTr6v9n5wrfNNJ9f8FGZblaVJDnWLLqJIQNvsG4R/s7Y7xnOY9X4QzdRdsgRaKrATv7NvXeaHbrJKQFPTGPpsqO+M6oStyYAVYSDzhds7vtIrrBF58zWZ4ZePGm1M71OvUxWAGMu9ujhmcvcWkQmlXjfeAAotNl/8gX5GPOhyJczvS/sByAOLibQNUNlzc4Lkh+h7sXrOVZmvliZShD0QzPcJSCCFcy3olrIjAe4BDZtyk3XK9iOzQqc97ncjc0xIrdc5+7kJdICwL0q8Q6soxZRp8Z94DlA0NAAu/ph+IOwdaH4YYfPRRaPS7etA4qv0aHcSYKQVJldLkD0fE/2WFieGwOJOpsp5dYDiFdNhCJg0DTt/AsZv6FS6U2LctIbfNpBSLajrtsBiQ1mPHebzeNX5N10LERNrRweR9NEBNyiiSrBwB0oiTE3t+gS+pvxkAps293zXNciHbLZTapTeuDWvWfqHsbUF/mpAYyZUaWsdtXPnNwg/8hRH/fd53xX5zgjV+vpmZPbNiJ2Iai6uMcFS1AxS/1AwhyqnSYEJeQkWRFoAT4BD4szYMUKYBSN1l9YV61qZ2UyoBRGzkAkz4h7HXvPvm357h44TLJgckh3fSTg9KnOPLMJnWWWbAJ184Dq8JE43BSgvjz4IITYfCU6Fh8C+UTislXKUwGPNBp83K5sfdQdJD1p0mJuIPHRppBoSe3IroZqHAmlEDGNIPENny61PWMGeK6SgP/kGmKWqa8G24xLvTnvxVSxHmBaWX5MS6R179e1b7WK2mwU3DpfL3804fyjcqOQaUpQyAcKLjML2h9VxrqTnKuJzYwMFU9arj6VrWVcHuPWETQ9dhH5mM20Y31C57odAXn6n+hz95L7Wg/wws7169JWd2wC3eHwOxkSjb9oxLCk00pSL+K9QxWKnBI3k6I7h4TjD7WSoRCC78GjSvd7ivSm44nHc1zC0Zx0ZcHG7zD/4aqCmJinZkybE9o6UGDTxVQwpdSqkD/QzIneVUyupysRK5eJEWAtam9v91H8494lR0OHMSlNHNPqJhLk6dEn1XTZ2XEMOiGDfx7yZK7XAgsmzX6+RAHQn1LJAK+bD85YBuR5CViuf3FiwgthgDr16u0NYPTF5SyvEWcjwFZusim4G6NYDEXTwfPB4k/TEvJAY3y3iuwGc9y4V2NtLQmIRT/j6M5X9XZG73q+3kwduhk5e+vFsSQyK/qThl5dVOCZ/yznyLJTAKwEhQugUMeBsSAVcDmM8hmIFJ+hQ/uWQsH/dBHOxGTiQqjXg+R4L0vfXbDnGBKdS6RU4//J238tTx50qkH+SO02kQQK5OvaqCs50WW/4Z7kHKSTDLaOqyuDheO/aAZnIfKTCS8W8EUjCQG79mH4XscBsFSlmivdLpjUEhHqX/BHtM+aWw8plFFDOpvkRSPViDDVVex5zirgjDHEKzd6corGvhAA9wV1dTG0FQ94RaxVMdRbJmKxiiG/yrwzLwXZEUfY0UbbZJ/iMcynnpTY5jdIK2yZlqkNihmKcw/L62BoXqXlqPPWfTrSwIQhq4Zi8yS4llC3ScHj+AXqK6DyPPC9QGTN99EIzxtgiJCNfKu5JiBEV2z2bHLA1UUYZnEZG8Jb1Df9TrQNhEviB3RUQreEarfk2TtSAgTFUNi/cMF42W3+iE9eT7gz8ZzfnOH22KJPqR1n8qBoWEA8TOGpxaY8aoreugf1pxM/hU5Dn2seg3B/6SLlvEIT2rhs/dnbatIXt/bnl/IdSUFEygx1EunrFgMWqd+E/AOP9UG8TD77OvRtLPuLikahaYTRuv8TogJhiAkm87jH/09VqTKilImQTqnocSeELWZKJFDlKyPqs5rLcZNNfaF2PKHiMb/Pltf/yWu2IBmmE3QGlUxSSSSBGVvKvCA24af5G0za6RjwE7Z8EjZO99D6LI0+0Abyq21lvKkaXzotBRumuDCQE6YiMQzkVl1jA4sayzWFAbwicbcIL3DfG594z6yEbB0WpVYgLelbuAb+9dF6TiOXvzzvFvh8FUJTtk28AksfR0hfn2ZzVnJOLGmGNz00duzgnpGTWxVCCbpKrZx/QprsKSL8dLVXgOtl+IWX9fGut5YgGWbIg66ZrsjCKwGTHkxN8AWbiJcnR354n9ijF2d1AvpeiyC4GCQFP9KEXXyOVx9mUwTv7u69EelkJsCmp4eWZh7qVYyMNh9JVyXXKV22TvsjnLw6AIpgwx/ddAN5C7/WiL+YFHd0tzLXMlqv2TbIr1SI7TUQ9DStr93gGX6UIjsjSz/occd9AynjlfUI7O6S51lwlZWxUpijgQDGVsFKX+eHef/P4vTNMcZ1Ay/BuQFjscxaV3XBHSnGaCeKhiip8tRqAqJFc+XbFBZj3Jt/7SXp5dwqrix9Sd2UVJ/AoOfpcwccX5XeYrnhVTPlPYeLHKj/FUT9zeO6FIKahwItSQKdWFhLScKYPqlDgh8TpzDFLFYX4pZ6tZTUOzN1SYr800tdFKL5JSjI8KnxhRN4l/39HcOtxXsq+Wa2CL8y/WoX3Q+1I+ev6qXK+bvfhhTW1f3XHqa6z0FX0IE4S+AVkPXJV1YX6TZnVZikBF0VSUbFLHUmLma0NfljSYVQoORL44wCWHJcF34szNJuFvosMwlc/kMaBkZSq2ZBsXxDDQ1rwlnbTLYbifbiZT9W0pryrCkDZ/IajKbaQYGfJjf7bJOuYduUoZxFNTO4BNitYdG2ODG4lGnYdNVaOWYBZ2LzNLq1/9Cz0UWbQibTWpOIPg2fD3DEp0SwdI/ygAS/Rdimah1lnmgFJG72nz/kA+BGGyRkG3wi/G/cEpt20cXgsWi0O2eH07fZW8y8GSOkfBzA2ZE2D519VfX9RPc4X507rm7UIZ4oqkaTMWtSmVUrckun0/2sRB1EEnNCrGjSgv+koz/0iASYTLrlotjInidI94je/KIlcYi1C+BVNZ5/Qup63gCREXPRg7vPlaWfvX9tNIoXURcQ+oYsngNuQ2mdiet0RjyzyhUkn5IRafGSHMzQ56a21CXgPfc0rOmi8/36qFl/niIfWCOGsya+xPtm/APLZ6PmjVGn8Pbo4EASfHam3pc3QlH6W046XOcHaC5BRoON4HrZLzPCd+1k4LyOArg/KczZXmr0aPZWdSu9ZIQB+zEtDeQEHw5yUswylVdXzvltBVbRz3qSYOlYLXQEuql0u5Tg6c1z4Y5azvow7/ZoSN62t4oSmpqzhutO1Mk7Vnf4Flpb1cDo6NAhOyET6lYV1dQSUUmPltBjBYa+ZtQQ/0X8DT6f5p/B0M++DkcwAnj6UQbf8rT+kXmgGS4Dypl1rC/xQMID4Aeiuzv1DFT0uTM3imzGHHSKRQEdCzDwicXGyYGxoCVGUI8p58+BKmxBXNyAgptn6plUsYRBEuJvQ9F2yXPRKuUtqBO3ST/zNsHjvCKUCEk0wGOcHVzE0bowzqW3h4pqM9v9FkWIiDWLJIlISonjNpXdm2/facwAwO3LN0JsD07CpXQSISjVY1N+T4q6tLnIsq2UpVJdeaROz2d4Ms56050diGL4H/fp0S3Gw2huSoNM7iGbaBm+sDQbX23wBR7XHhiMUjIlRrhtGS1IF/p4X/GLReuPDUFNICyTT8l2oahzsP1ehhSliiiDmXxzVfy26Kvr/dXqjsBXjfAZfBJUq8JtvAIpW2BZiVVKW2VnEiavAspAgG0rgXBcU+AcvKuNbxDHPkR+Ue+A3aFHxPjrPItozohQMmno7sWL+thxPtQ2P9WaiXKGJDyTPoKZl+KBVjnn6/7wsAJeHQgPQZP6kWSxT5dqhRWp0xhroA+hzwTtCEg3ZdWEf/hSMpslL3ecw2PAbC3RwDh8nIjvuT9cCmxDpD/Xmx9hk7z8xq8gYPXywb4p0243JHIwUqk6gtYmz3K4hz3d+LWvXX+KjIa8VJWGX7CjosWBpcTtNdBRBxXh1HQD7DIycnr963879sPHZ14uXp/3ERZs3fYmU9jjA0XoLxjd8xBDbch52zOwlgRL3vaKVgVicyr13RzvVeKZgBjoRFFkN/NQp1lCOUMOD8mUEEnB0VpLy7veD++p6JSqyK334t2yQIXHaHr82Q+e7bHHu5AOT+M2GwQdZQZUU6lkL9wOQbXOJu3tJOytKPXxQdvdPt6iymL5HY+L305kDJPX4nueKlkyKAvp3m5ETZjISWSRw+hLxGtTAOA7V5FlOs2q61s+2fd7iGME9Dhi+VwhaHSHSgXs1rc8jiBnnw5dtYs/JhlCEK/inNwpQyss94BECjj3OeBBBnVgaRThb50txb5ClREh1CSfMYQJ1966yDO8C2FlC78vnFox4wHgvKDgt82xlQZGlDXE5lH6J1ZQUYvR005A/4kVHXusvhD3lCKqPvDf2mQfbPzkGLQMxxmWK9Jm6U7YzLw51ctEjZ1t+9CwUAK1kpWdFqEvZkFv1ZWnmWVuL7OEk4Cdqo6nezfm7c9GuQRk4F/uhLLHNcAxGhZeQVyoUguLJxIIS1eTtRXmP54ZWqkWbY1l9E764TGllT+PSzjcMHxcwtcbFXvobQaf3aNvv4wvWDF0n5SFpOSqeXQ23AWxMD9RD58EAEjMtw6U8QK6G/XnZfB9P0hAgeA44Uu8A2e2sn2khHz3QLfVObAquRC+DI3zH6JSY+f8cyBnOwfvNwaCMPZiHFQ5VGUoKMaDy41MzMjYw95hmM8Gu3UUTAEMvY5LqBkMNGTkLGehPa7JpLF1RLigzg90CCrlcC0l0gCVwwRie7dJZyHUQwFjMsROZGLLQZ7x558BXxRZRUrPcgmH/q8pTsVSgCYNtMLk2jVWJxEVB44LPn5uVdCA1A9XigBJVkGpABOlwK0nFF5fqmIm7SlJjEz2+nKDkzf2XcVU/LiPTBoevvCA3quveUCWCAwU0A3Xdv4aUQCj1URThG4NsRXeo4vX/K+y6xG200RMyI8UnFd+ylL+cDmSLrLtr/PJisxdK6D1PapuwTtLBRrgb2A0d7GNhJbFy+o1N715SvgHFWFMku6d/hXn5WDLG0Qem30egrxcPd4hBCEyMb6ZK8zt0WFUYh3UJzrjIWXKhNRBE0ifMLAxcdMPAIHRikbY2xVybqn5XvLJzWY57stQP8O5F8cDOfzr7x4Phi8cVzysUuoDfmK9aljaATi86GKHoO0ezEIkt1duWg83Zvw5oWLfYr3jqMfk9SatlYz12+Nq8XgXY4LzUAYbO5gdtwkhwfZt6X59u5aK1YEeQ3Vx+P+AMZ5BmLqMsjjBvYLugARiMHBvr6cxgbGPkpv8LAVHCd5UcK2HNcI6/izkMuhcgfGzCxSH+3igwi8yF2ph92s7jVb/2pW7lUcMVryq/FE8lyTalBWLHZf+8DMsXiuW5pkXItVO0CMVgOx96Wki0F+I83bW0bgD8hGGA1traTOpBgcX8xlBTouAe375O1+bT9oMaTE1YBpxtx/BnDdI7m2xzB4WPz6nxTVYFftac6XOxBYrLQM54M1uD1OPG0i+yiSKD6A5rWLr60MkXHgACV6ZWn1OEAQv7WqG0wXiv70D1D+197sMLQ/L4lTcwFi0ADn96UgcfUGLFB5JziAnVcxBvjnv9JFOjHAS+mPqApHtaonVcr9jfKFhyF6EeaaHlUFYOHTb2FzUf8m7GpbmZvctIdBk4+xoJiF66caL7aoi15g8EiZQsQxmvOy4WRWSSh+w4v5mKl5OpdixJ5E7B2l2vuRV5lv0UbvSFdvMvsm1QByY/idB4GomKuCVpE3eVeqTOvvPN0YeOr8sODMARovhobx9kkitIKuXVfjVAy+vB8sloqaBjrR1hgS7WSWEd577IiM8e3bzl3f/xMbpcfLwpJAgUPFVY10J1dR26dxqWE/203iBmJHqmKomrhMc8xci/HV6627o9fpmWq2SsaxbfbO/LeK8mavzzXhswLHwNyW08aT++suHqhQm26UP9Xa7bEZVKooCIKplX68EGK8qaQFXHXn08sCuR3+x8q4n77E/r/QSgb4tbW+/9siFZ+HBkPgoL2EpiWiWVuRk1m52zT8GM0KRGSbP9rj88gwleBdGLn/WbNH5AMLfkiHs9fbf5E6PT2Iq6WcXDzmhWeQ6JMu9M0ox8uq1fmh5oI5gJXnAKchR1rV9t51QSGB2EpyIzi2tQpLhirTjIQBHorpa12PQdpYt8FT39A1vyaNJ3xkek3pDWx9eatBqVD6Ag5lqhWtDAKcu/OImOBEVGoIZeYDBd1HklHaC8m9UjjlWCfQLmygMXdmEIF8BgvQmpdLgw6TfzPF9ZVsvRiZsQhjdo+G8jxDgO1xbi9IH4dEVMXVTntw8YCRtd95pGn/dkKHz6z0dmONbgC8Wun2W9L7pRyRLMg53dpSSML/ZGKW1X06bOPTxHpNaUHAcf+HRQmJLrhqB7A6xSnnppK6Z0ByD3d2W31YEOmkP7yJUU+Fg3Ljd2SEn6JCsfnMjg5xVM2/Cdp/Vjg8EbSkZ+4hjOFwvDtSzQ73+Sj2d4uT94qd40MnG5C525Fpgwge40bLkectfSKzeY5gRDHAEZEsFEdZJCa37YbjfrqInpYsIc5Q5to+cQ/d4kN48ckU11C0Tb3x38m6NllMiPrcZxgLMZrfI0+2CFbas2j5+cCPKPD0vZl5ewdS2uHPY23n1DX6C9md9liafVHtyjtgrlAZXq3ggpHcP1d+646YHZIAbRHgj75pasTc5ZcZOXIbBGbZ+tOUe/q2SK/blviWchEclodSdXeElBkwkPv0WSluL3xpLhWTQngUrTeLQ4j54C2n5s+OCNL7bS5SJmShg1HS1jzvWHKQi5j2yguR9BQ6E4LK7uxcrfqvE+aOrwKH21hMNBBXYWuxLlIlH8KSt0lGtjJ0CB+PZ+rJ6RICktCyNXqTD0O6RHr9abrPpKo9+D3nMmNM7iv/Bj2JGllcmqVFBfkh1nw9MQ6QKiwvGXZyya6zYSLs6qzW8TegsILq3SaE36lAuwsGoBjaftX5CV4A3IUWFtl/M15I5K+yi1RTa/chpLUGC0LmJMlgjB+pPhhKm/FnTmi4L9/84Dg/TlDao2+HxMRK1v+zBh7avy8I1W7Vfvg33ME58p8vSxOgDDvFf9pyz4TnyE26G/tE6D9CMfJJdJ08ex42j0SlyM1wPmdqXn09FoVlRvjNdTH1ACJ89dL94XqEswwYYdNxgJJDA0WpcnSd51iIf7JP4lSNyMOTLzvV0ekrzNWtMVmeIKrSfPR1U0VpsIWLWtO+Ca3hfipfPlIq4dkKSrYvrQfWuIO1TuWB5dQD4SxXGjouH1MEP6tl14JLX9hPZX94NYzw8A5O6kNJbPFB8ePnJRmmmIv2yHdslu0WS8XxzejfUPlEcVAS4TRK+9AiQMI+TqRbhl6z90vm+afW3OmhctYUBWBAoyK0wyQxLuMv6YFrHEnYyfKfOTUZ0fqD941pza0lhsY/TMuFwhEksSOyJ+X+BzUjKd1MEa1IP9FtXhkDrBfDyF08ohTwV0TBf3GdkQd4Rmt9l1csLShi9gpCoAE6CpeOmKHWIh6Ye6njbPTh/RLaDb+n/dfBYdP2lG9ZUXPyJP+WT0+aW1PaRz1zYAcVPLmj+gSEYhSoBWa7/axN5D89nWQYszwUWzycK7ewQD+AhHBPdKNyQ1DQYvUMiepD70pPLcTy6V+JpKj/qqlRzueE/8oOD28P6dYGzdNKaappydMO0R5DrcTETPGCC6hDBNMdgqsx7tcHsEHesD0nP4X1Hj2aii3oIuGMhzlMUcPCVwEPvd3V/xcjV1Fs4imwgyyEU0pOxIkaH7tRagAbMJ6r6LQYF1q/mBvrXXhTG3S+XvMOVyvzXWZ+mEwMgTYD2Qmhib1w2Kf6znTEyPX9u1ztql00V4jwf8MhB0tw7ophBWVY2Aq9g4arayE5rKAf7pMP0WdbFRX05Qz+63zIB32WPD5WEPBGi5MScmfHR6eLWuE1LCfgGR4f/XdaArftqw1IaFZADw/mZL1SosmaY4V1d7mvhBtMQd+n1WnrrQC6quo5IxnczFEVem2BrGSziFWva6hm8H5B50ijkhGAQSANcwrk8TvVYhIfhnxLrzr34iLVlhtQgTCrzFsxXTS0kcblycj3VgwGcTzpaFT93FcyczR82fbf/iDDRC6q/rjd3Cni1zdflO2koNzSeAp7hyYs4wGZdsGxqHftKOJD9HtIBZaKfg2JvNlNr3YLNJjXvXs00mvz5sFAv9FcOlepgDkLRvVB+/zrztXbrlRnWZ1qAvaF5BeOQBAxI9gtsZeaP1RsGhARW2CFZzsxn2//kLgoToupAQEAVdZAR7QMZJPeDpeKk3E9nS8UNDvesszKph5XePqG+u1AFpKaU0J7EfOGR8McFbd7hwYiYIfubKBChlxBhbQIGzxot3VP5xkvG2ogT0wjiQYJf5V1d2VkbFC2aVVPRc4XktloqTo2xnexipBfB+aafAZf6q5A+gu50fzN/0vfkrJFeJtOSDxopP4i+oWPf8824LJ8dvMf+AO+q2eq28FKuyaahn0hDtWQ2vywrQhzI+bJvGGTrDVVms/Nl9jG9r/J/kAKpXnpdI0q0E0VM6D6+xpwTU2jEPiLz93T5mQCP2ZxmsAgcJEoRswMXVEyHbqhYOQ1+EG69nJG2Y9XPTRP/V3b6SWJ4u88q2HRnOeL7Bq5gHpCSY9vexxWrIwbCDYzLOrvcs9oZLBvYjkX0+Scy2ON7heWPTxuUXKIYuXdD182QWHC5cX9J4l/XtE6vaCfSFDYnaMIkdhhPjbsq9uQXZ6PbnQc2duipmiAC+sqbgSrMtHTwNIVlxOaoawZzy9iDBTsEO/OZ7+ia/JAmHjW/XcDBFMHfdRojLWN/BMMrsycEvNucBDj8AiUmb1f8hlrRV73xKt9nDJCpmsFjZbl99e6XwdMz8O0AbSlly3J/hvjY6JMNDi7H/Xi6cQ85O9gMcBL9lFCfq+MeFTxIykzeNxFrKcyD61K8WFy3KN40u+ulNssM6DZdQYmAkOKyXwbmlc0GmzBIQj6xmEW19xnNrW7gFSNKej0JkqeaWqnagA9Ok8AGwHdzzcYjpECS7ikpVtmysxW3iUDU5qsPAl1lZVWzSfZYZLPG0HRJzj2bDkB8uaR2pQxUr+PZQpvXhpsDAPOLVOGJbOGm9GYOUb2J6CNJ//NyJ3FPgLFkFVxEVdajXN6y3isrdmxJZ4q6SMcPEunG5I03tLFKidQvbkx5PDbcLxDAA6y3BT0ZV/IUvJ+S/lQw9l47v8sxSRHm2Brq5DPkPy/Xfadaz+5WJpjQUmxHyycPJcPpTvEEcvk5qH22Rtt6hGUHOWqYKcpw91H46lXRHRB6YIqB8a3tvg8lPwshv5KXXgY3CjhV3o67n/GNIP/0VRpuX3+FO0U5OYr4WwPPa+SdxctYH7NQB4tJ2CSfnrOY3jbHu56V0d0JqW/sF02XwKwWFVnvlfncJVrqI8sUErzxVp/i25FDNFJV29kG0+dpADBzBtCJpklT1KhLHgAwuwLEz0FTSiw43DYHjV2YP7xs9d1GDSSBK+ECi6mSaOZvbP9UzxP7XJcQzYqsz/g6og+DCT9rmBfmnLRbMQaqu4lcIPgHOe3T1V0rbYPnswlo93lkkee+2nK0tBxssXNMlo4PTM0nrUFZ8yz0gxrOhjUh+sHLTWWOZoFUSUgBaRj1bEFrDl5Q8F0Dd2X9CfzUTYwaG8YaOUMNIiAUurxQJ0dFn+vz8OO7Dc4GOEmqZ8pqbOGKODbIDIGfz0B1tLJzaK4F8yQ2FagRazkfkVkder67d2pyZvxIzA4N7E1TrAHzFgTBwjuF5HeBnpkLHmnG3THlKPy+UvyZYEP8SsKg/iM/zr0zRqZOoVYaHoiYjP1lFyU0w+wiFMTyqJ6koAc0cIUnxi/YdEnbpl/4MjCpFLCWErQu9B88efKPJHadz69ik86Pl1s/CjL46MV2/z+oZl0iHd/NUzKEo92IJmFoBJqZp8i2hjuUbfH3m8B/SZto9F8BCpoVyX3mgC+tiCDdTLSzLBWPNAPE5N4dbPe+/y/0Nh3vddWV7zSisNPbHq8uZ1Gxbqp/zWL4k1L7lMNiPRn87kmBa8uwqOtlZyuV1NWRu5HkdiXtHju2j4yK2u2FH6rQOq3hnmgGE6D3O9n+La5US54CfITd7gH1UfPmSw7OyzWCsNZjbZ5gNrMYntNAaZGegA5Qqcp83QudOhOXjtqbQAJrTT0U+7aQ6MVcO/dM7OzTI2s7Q+XzgfuGuHpwvUXHWOY0aSRrPx5WLhuRWNmzufPrnzE9JR11qm8c0YHnFDQy8Igv90sxSg38qIZpzhN5TxnCG8KbYELD4C/MMUkovLg8oVjfxYQDEVoXpDzrXT6GMs2kRpgYXukZAy+s6SyNfpBncCrBUnASiQGkx6iUqd3waO6cW4aMR74/x+JtNr3ZBbW/y7qD10M5ut7bf+q8reoynVtP8Et3zJjuzna1oeec3NtlYi82SzNzivlPXdvbykpVC0RCKefJEsLyJL6f8nIkZjoq+IBELyPk7D+cffqflmRM/ZD8Dvk+izLZAdTVFl9cK2P4MOUxJ6AvTtddxG6caVZRXNRZDb5FO9iMexSNdJz+01SxyqxYHxo3KsFxXupaGKigYCC40z0jntXe+UXQ5FmJYndq5dxSQ6nytXB8OSd8V5B8cOHXzlVCjz3CfgHJIuBzriODXj1DaFs5LcRJHEzpUFjJGPp9AKVHUpbOD5wvAQncTtMfw9WL94k8zODS41j+yRFXifUVcHscSpvhI75JHa7mH6ckQe2zlCwQBmd0c2rKBCveG+X2jQswYkRRaUDFc/nJaO3fV+ZV+DPqbxul078MIDWoVNGQxuGR5VxU8DpwZgQ5ZWYGIGydJY8rJLtYvPfL2RApwpe34/JmBJfSvFPcQF0iukbyzzInwbpoqRP3zD9oSioYdOTglVjis2mBkzaLfX1mJdeo5EwHX2dztKhG6S8/obGTW8e7kDNoGwFyQeJ6zZ74+psZtngdxqDOHNnZp7uP5ogNAj0axg96Cu0HXjYB4pQO0x0sjhNtsCK1GNQN5e2B7avvXj9CAgsZ8oGgE+XQpkDY+btC8sGO1yAnk4MZeRLsNnUv6ik0K3NtxMRuRZga+6a7H4Lhi+puHxmF1wL4QRxPMvRvBlL16QDSpGW4nIbrynZri2f01L4pWCe6JGF76Jt5hPAryoISsB73NI1OXnIwZ/T5Tmz0AzOWvdssg9UPSPQdvhe/8pFberotTFuvztn3fXiS9ejJ5TjZabTwPEEAycbSLXudMQtmq60WF5nR5b4ymTRF456Ze3DUFPhG4n7SjmakVOUs4KJ84c91I7vcCXOvUgcU02HhoM8ZQwdNC2+a8gPEwvnWgZmqk21xsjTh07e6hOfZ2rNbds5Tr1uff7G0MWZFQbsc7VKJRi559sdR7GfST4nYfZXLfh15RurDdeeEMYDfQX99/hQhygbkSIEjjh5mcsgsmn5y2g5y0SnfwFk3F5xNOCPsZOl3CUm70DdN+7DGUFlZU0H2a2V2m+lmzc+28BdpSYplFx7sGpW6YNbAY0PoU9E2qaKHkuVc3CTNwqIIQ6rVzx1tU9PWTVtLTfVdnd7JpkLN6Ji0xHSQd3Skn6EbXtOrPOzcXwhJsg8NjBIx15jV5Y0+50GCSRheJYnzVuxQyBPqRmoTRzCvKExinrl5ZyatV9iLzrIq55ze7QI9GSVKfeRhWTbFM7vNL8bXDgRAeR6nlEoJRGtgSs+FtguGEJHKIstb2JYG7DPz/+zqBOHIgNTnmv2FkkZ9ouqJSaPnYJsVVFUv2fKjIrdHM/hCGlCTvSphJB8wDgr7sERvVASdS8IZ1g8Cbn9WM1twg8OCGFTPy2i/d5eXc8H8UNBwaxx42iTw8NDh6Cei6FR4+cHtWU/sKgtO2INgVSTkB2lpqljMv8PWS12LOYpO9BtbiTpDPKrHfDQmai+DFKDH/JRMSlIvKnJbW8e4L+eA0xIQfT4D32DDDziFy3ACOJmLkDlawuLYjt+vbOh9xQxq1bvMwfCLGDHpiUIOVwTrHRNgdMgk6J7bG3qejiRTiDkwSxLwNzze3IdYaAyRXMN/xYxw9bSCI4i9W7oZ1prF8t07qmH8SdjLVo89peMaHfveLE3r+Kt5Sx9XNpWxXOxrey26x4VfhLs+8ZroCeS0vpGn/is4dFlmXsKuIZojrb7zriAVC2wvABXl2f+Nt4yyFEsJsB6491Mu4DrjBmY4TJV27EU1aLaAycuXd+zvfCBq/4k5nsKeyQ4+E/8xnbt2VEp2RrcGV/+2e8A5c9IFnV7lymzV+z56M8g4MM8ZBUZ1ca/FC5Kgyv5bsxpZMWFSKL3absqiFtaUBrEKD+Mpe0Zw4/+lp3gb3x1YXhkylxXM9togmtaPQIPxKyD1FLpb/qsIQGrTiL7r6FlZOqtdDKSJ3UzMTY+f8rbD05xTy/iDrymZWSeZzEVc38btpt9+t55UNXVn8siHEqWGgu/g/mPprIqg74kegbpVIFL7Cvpo2+UDLjNQLVRPOwo44o64VyO3hdj8aA4D/2tbIk00rA8jlAnAw4hbypYgoxIaUD4EMF6rSf+yuPiDLITKrKo5UX89jIS+4lPSUBI+IqtI81iq/TRsAi1cWZwjBPHXTjdmXPUDH6yv9rcDZ3JAGm6hiXRfP1pQ089GMjW45e1Z/efymVlhHVoYcHQjlKQkp3Y25OvwZU0eJ3erlWLAt5ZaepFB2fJ8YZ36E/cChXy7B+M0sc5uWdwSY3dwZwMjZh/1/bh7rtcolR/FciL+W8Kb/8EE5GGx+92ouY1yM7xz4o8k8seO8T4eFBNJ48zITGos88UijQX/CrBy8OrJmTzbLtBcAP6jcTtQPdqDKag/hzilV6bIzq8o8a+7wK21e1MzrHlVNQ6V1URddfCQlurUy1YdyYQRg0U6xoi5MMtIW5pt6nzc17Ju0k4BdnSU5WpsC++j2B0HQAEgQt8dmi7iio6O674kskopu5BHcjSwNqF9554i0aTfy2ud8z3eOShiYvgF53vdl0xpyqCAqOm7qY7RGeQxaGRin/V5mRrI5vfl/YXstOifZ/Oed9jv8nxnExNZsqMEsQ+gjgquhaddyeGe4hsq2FJkTw/iOl5zU56tLX9Y2ddAbpwQA/LDK3ZMRkd/7YD/9Wwj2jMC1XHMs5zE3tkyy8Wj+HGCRWMDWv7oizZwPGH4RH1A4WjUt8d+L+hVOZx4St4CLxFuj6fYPiyLKTc2zYcImFx7pXLAzLBJwb8j1QZx6FYHjIQamT1DVSt9crRU6Ol2no+xLT6wpthqCz9qSTY9A5dhpTj/w7imA412Zdsm+KqyMMsfgL8xQIp6yIWMBCS0SvOixE2+eJpjPg6op55vS6JxgtJjO+8IoQ3hOiVkeWhvIB8sWcMNs6jcJbnCkNTO9WpHw6iXHCu0pLhQCCPcRpe6s3X3wqS/r7qHKYmv8apCUQL27JGzTHhargjYAH4C3YnfyKNFsswmVlqg17UDzLbkFQlDbU6gZDW1MwMx4pCoppk0mB218/yn8FCzM2yV9WzprM/CvjBEpTu0pwnUh2xoY3frcpkrP9tTUTv7s3RRSMIvM3hb6sNDS6Gr5EH8f+ufR0yvAT1P8nW3TDycleo/NIqnSo4NCw6xwdQW+CGzdnc6RxCiqRkN1/QyvhDxwSaWX0Bnx3ZffSAtcii8aFShI8lSvnSKNpyG+A2I2Wo3IURptYJRt7fhEvb9pgBCmhorlYIVrcNURYLx7DP1ES4q7JDMIBd5r3FXBvqsHYrIXxZkBlZLDWLJEIHManhQw7FDQ8HdskvANAsp3oNjaXuPw5g2cWc4Qu3w6YhnLHryBuJdosoWV334ejrDLWsR/1k2dj2rwh20ag67Lo6G1JDlc+aKnERiUhtKXowMQMZBY91vrFxslFZ5NihkWGg+3tw62wZXPOEhYq5ZDvfYDxNxPHoFNsa5Se/0N6IAIGH27B3NKFXUxwlltKp+QT1ITHAXvzPmQgcAMYl8nJD6XxIiEmZMz8DaYHHnYUsIO6txw2YLsXeI3sjYH2GAqHeQPss4mNRVerLDA7YG+Cc572kGtBBukqzND1TqkoHptlTj3v6zCgPgEv23VAVfIUU9ebLjH1YlJAdVtFzYDVJDM7OOcb8GMSjrp3SJElh1Gxv6mMb3EJOEXRVfrJahMBKT22HVu5t4Vl/bD7St43d+sg5z6uCrodqU5gWkqZlUAtSuzmo3y0ZuAueB7nmuYovynYiClbZd7/STTNgzK6SPWgZQXgX+mc2Kbct6AFYu19mlTte3kD6ORTgRmaEUeLOjqeXwQkE7hSgxTHtX+z5+82QAfJHEp8V7lY3nu021TDyA2YfsmMhS7rGGE9voNDF/FnWSIfEAyhUQyEIND4x+p3Y1a0+27oldx/QvARfaIHzPt2EtotfHMbvoocXO7H4Q0xOguIMRIleEEOw0UICJRUIejBfGkXhO42YlqSJELU9Q/P1AnV6a/gRtKELf7h7USj+uo4CHTkNHvVGU7uKXOaDAvuN478QCiQgiT+SceW1Dgl8wL9q3NPX6N81t3GheSIhtB9UJ20rSmMkjPYMLn1znOq4dlWwmAE4mw4k8BVsVlI5skm736XJfXrPOZKyQr1F24aWVW8hnrZoxyiwRX6fFSTCjXnbe82F7pFsioG5q9gZR6kzg4NH3l2QeepWKWloVO3piuGUkWjiFlW4TqEC3+ly5y4KSr+Pq+kRd+wEgpy02GK/M5fRwxu6N7Onet5D8S3Lm9ksUT6nSgWnY0DpViF1wCyiL/wp118BSpp+tsiDZ2X5pmOwi0IrC+g6/HwkL+59wIf2KNilNNkHtiwXBrnuqxUfiGteEeeddLAm2ovLZT6SdF4HUJa6Hwk73XIpPUGr4jYbil06faLTG+wDEt+PgsNxkde9YaREfQOa+v9nYCZA8t4QtYN1h3V1q0lCYHPkhv5ChTPn7wA/CIMsweCuWbfcz3i+rEK5NfRkMk4hEBlOKpFdg+6U4ZvAs0b2I3FjB0J+mdSV9lHW6ztH0gR6xfh0AdH0gf/V9YWE3dHiZhi4K3Z2GhMNVTT/TafA9xpHGHCw3iZPoW78jOquYecSDzgCWyziv5M58DtD5yuBab3ZGHqe52JHaICKjHz89NlBp0cUEL7v01CH0ClaI+kTyuffqkPZcSb2QNTSjejYF/9BEf/cRF8j3eLpSWdUEmae6uwxVTe5rQ1l0BD6eZ8+8DjteXUTCIoAv0TuV/PK652hPoR/jc8uvtWURuE+alhgLntxOuwWzOIXVWfx7hCCpYPtwMZLf0ZBdPTOEf7xC1Anuqz2mYI1LKvoextodXxdi8V3pBV2h7bgLAabTbcxigymUY4cs86bXMq4eoQXmk19NVYNPZAN0Wlm6mzxHd6PxO5/FpIz4Zc/K9yaky7+BHzOAUxyI/jmb2FQtF7uj+awwp60OLiBve0ahYoDbsuel43wJfaXszp/nl2JBSPl9dJaVrJS8L6/P81leHejn6iMNoX9a+g9+JRXdiy5Mx+YO4z6Esw/eFGdG3KA6Tk0AvdGHSitohIVYJtq56wGMxnwn5dAYPhOlj/LaxUp0jjFLv4DdVHsHFjsEVp3iTV8E7jPp/CqedQn0Cp9T+R8Nto78H6rl6l1IWDtnKRRZAxgoAv+f4cCDgx7K6Q4fDx0trLCudURheVenTOJJm2oqdR+DfHhiyjaRmnvffkSWZw1BxZRXEhR45AyBJIH8dizAPzdE/dvE1Ig4H3w6aGvm7+UN8Vuu+T47pSFIRnutTGFzu2YLwxxVHcAEzogu8lsVjVru7Ta98wTtZSXtzDeHeCL2ZxZX23F65nBg87wCRz3qvv32MVj1wfO4W+XEYfgUJLfoljn70Y1fH4zYNpB/0etx0uwUhBAoqIRmCH9BoMyD7CeQA8LyO5iBSf5na2LAi4zvUpW0qUH1Qc9HNWSPUKW0teKUpH5eu2M12RR3HabPJfpTWYzZrG4AgyT88/f5Q6GSRHT6SyRQH89+qhiu8hX4hvmxZq3ZEb0EV86L0ELXWV5UE54MpuractxM+DlEfWscMFhhsxfs0g7fqkCnJ6QWkDxjkxAkxyDDa/LTUD0p0uxQVIy0G0QtmUmJHnIWEQcJFh3XWrc1ix2rZaciqmxW8tKLE/Epfcopw5bLNvjnkwYDMRx6O1ruHdWRwIwMQ8Vi6Hi+j2ZkyBR0HYjSGJQvKJobMMOtshQHIosZPqh2WMhhjTUFcb+sz5p+OEXhEdeGupuyTfDgbxOIeeMQfJEQ5KgKw7GeE9Jc3uRukGw0FpFMj6aghLA+/a1+ESZDeiXtd1TiUhcoSgSGB6JVOR7zAJLs5+OBVuVoqePHJ2CYJRjJxcxWA/aGIjO30cDzD9XrnnijB1tN3yPH0Xkc4+RKZmBPSY15uS/V7UUWu7glJ284AHmRqM5SHRwVGBhrTN2/Tig3KUMSjDNIVF5IuaPqZEQi59DcGezyDwzAzs9B1EB/iDn7GgtqVlrlYmOtClaxmCI+pk2PixzYMrZHexEqRwY1SXoqALXNzkaTTZsbWoX1WRcTsulXih/IXFpPYvxEa6AFZfx4xlNMzfOIuURcbu+6qvhaShfh+Xu6Skq+VaDGNaouKpxYOb6B+A+1TeIIG7L3MR+5HtUTDR0gbcM0uKZ54PbkxAG5bhsH6nHmQ+1G7Efpdo1l5cJ7IIcHh3nGJWsYl3QvvXZahJvPx5U6JmLQvoQDJcEbrQZ52+C3RFr11pZd/MUURv3tQh12/tPB+hwr1smNoBUf9lMSb8ABhu06yuNfub+S7M7DbIHrBRm/fEBfMefmVYUnggJp3yuYbqHglQb6CQVmHsejqaZ9MTz0arCErAuqyGk+Uf2rj8QARZi5qCwntCP0fj0K3QoxJlgfpbtkZGHFTStCAGBKKY38nl+JK9OQFFzQLgSKhPLNDmrHi/ZsHGbIgdSzwC/ZW9u6ino7sn4IURu2ACT8iFV8CjpG6t9tyCvNS51cu9ScQsin9+VRkjKfW0COinXNUjn5t9xo38XQeDcrvjjjLPAkEIaSTQk9+IEH7cREwE6Hlb/jv9SOfdikfrQlJZqA91x2DX3cZ59rxYmBbPeGKsZNFIOq1SzlJrBSRbwpGbnTOIq3jYzhp4DcJIbl5kzdjpZkCIHT8vVxXgYEbppaEcJbscPnqVFYCMwm1P4slb52LS7bT7R8DACUJmb/5loqQPTUVpZCkCiNjUBpJMxNt4Zqd44yl/1lbnYCrzYGROsDfe/Nru9A2zN3tyxBfhod3Q79Ss+L8nLZqZgs0K0q5HtuFjAU2YP+vALFkwG+iauunwAN4zr27SZ0jA7vn1rR03o/Tu6cQoL1OXqpVWytqm7O00Fk4Xob/sw6mCIXS4M0pSscZYl501NGFbl2m3UFfXsPwgqTbZHF6XB0GjuRT0IfL1Vgb4eeK8Cg3rOVsmwrhRv3VZxsyGiZtxYXDVqaf4TfDoRRGTgfI7xR1Pd7hm0bdTuyUQfuchelyKvZHcVGKcLT5/5nz5UH2Xx/JiuNJ8NR1LTgQqYygh1l15DQQ7y+CpmAgA3XeHKoSsVtGRwahxHBuUP/wAk4uGaXXDb6K32RNt+pImUuKFUYYrBC2Iw4yqGNoId2qBgSXjWZJ4MXNTR4vO95IVnC/agKFCUv9o0afnz8ZQnCflqIQkUApTMoEA8IpVpT4yam/ZG/kXrvTcq1kxM1FPvvUQ3hWKc45O40QZ3FZWgcsW1Tv/A+G/L6jgafXeBqR2hAhgTilOdYLtTPwekoicpLZ7ifcgQi/fcdAf7Y1B1/hMeIs8PoXN/s5/sVBTsU8BcbW80zh52JS9P9/5B6p2h+2nnjYOs6VUyJOJQpFcwCl0TUlPJ5o2f4FcDzPAqjbAwcp1jE1GmneY1InUnqAXBc96lAFjHPtkHRymGygljFh21YnS3cEt0YD9KstXUbmdLfFJNYPs4U/4qYnxtHS4wj2QY+/K5Wo3zS8wlE8+/wmwnOyLvNHI/zirq+IzF+R+P9FkOJaDfOjT8sNQAxhUmVlKDvINJ13/FMw8Dsr/M8PvpQPzdQ6WoZLrT2rDOTpV7owmaIZtH6PkIMvYkyWWXNo1LsHBhHtw5ciKaIqYayJqF7e7OD0v7joinvm6/pz1uR4dSJp+Wx6sfNl6MSq98ViAzOhLZMcdA9ceviQMcd07gOR+H5XVfZf6rae5tdAiU/VCw1v/YK5jaxTwikj699YkPsezR1Wm5C5ssf6hWJKTL0bYmr3pGgVxJpKwB2qB+q5qweZEPy+byaoIZEJ40hqwebFNnDLKs9o95vJp/qtMNZHWbhuaY5ctDDwvYf5U5Zmcu/hWfKP/Cu1nB+zTKDxVUCQXfyox4GF/BeoT9ZYsgqNmW0dBkrQ5+Uv2LJ3sOOwZfWLnrPyCIt9K38a7WNPrTirqpnDHyF1Za8FdT7YIsAPSu8aYuUMo9k3cNqYdOEXtv9GsZZqXJe0I+fwRjc/QUMZt7ya9oCO7EreLR7CXHQzgj9IFXAId3My2c/zKQgCP8dI6nnsF7sMbB7gOAOoyl1UIDzTaWdzvhr1ScfkOIdJRA4suOUsY97Px5mltGqpK+HCvP40V2ODlLQakSn40PreUfiACkYhAIWipjdfqPbi8TT/Eq4KdEJ9FCJ2tqE4ytCV1qfeWTW6DlDEmCZcQmQRbrPFRUZc4SjHJbl97xJj+tuB5cQalGMMjAOpPxZ3v32+ZBdCyQT11zXX85i6XBOdcWzP6hYeQk8SAb7SWjQQLmUWxogC+G8SMLvJN3IQgePY1cdytm7CTboNaXlY/Sw54JxMkL6aW6HBGna7wPbr7lQTIwrcTD8477lGE2kizghD9Z7mYrJMCt1VrDW+rJt9o0Bdwq052v/pjOrtospGzhTixi64DTjwAQv6cbtN+1z4CCzEAJ7ItyLUdm/jOn/AiemM5jEgGD+sn1z3BDQ6gnllJWMaXgOz1JaMLr0Py8kA7OAM+y8/vNudErmqq+BzsjjTQ79nwEWHemAVlJlvsZwkOHfyVdLCmMLPSxzPWek7jcoYeH6xoccyZor58SR4YVZ4dn9dGjyl4VHOOLGpXcDTqliVrzmAf8EbgQ8M/KYzmz0Qa9MnZ2uMkh5MIBK+5aj2iOwOtN6osqbPiSVLnvCN4opR4VGuSN4O0AqcRzD+jieoxir8q8axSmHNSRCV2gdJ1G2QSfdX2ztOnCJw/pWfAKXes7bRVNY6kt2zfS04r1WSaCJHoF7wa8p87tbrrJ7FtlztUhtiVaCBNW6H9wchB6q93WGfZjuMsEheWOL0wT3ZD9zf3V+XerbbNt+KTwjENLQmlQYV6zb+gA3sms7qXKbu/HZ6pUnLjsG6i2C/KBIP5k1nZhX+7qykkkONDR+1WDVfqnv9fK61Zhf1DIgCfN7J5KbKPbd/+U+y2BJGAfHdFw4H7ip5yBgp5lSLS1iPSTEjgL1DS4A6xyb1OcaxBElI8rAoSoVSDYm8A53Aa4+RY+YHSSZhKKtRM8+WMSXkdrduEn8FOJYTT4mqibRVv6gUXWWueywPYwsnq0ybTcYpngqhbuD1nUcsHE1Ok6jQ3yk0HwcnbM1QpOIHnI1BLJsfitDd4GHp6Iu30eo+mS40fPsL/dz5JybgWQhZ2OjsQGIFIEISWp+WepnTIvrPjw61x7GqZtWxoab61L98uqPaTjPsLlfHSWhPTCgdRqVTMokc1aRBuy/biz/y2TTWQip9FLwSq9TXqplx8OlPOFE4h2Rl3XJ7QEV9CgRX00J9squU5BjrDRrD/W5uxSijqSCKeW9svlcns5TGI/2IUhWSmhZLF7s5NjqY2GbV+c9mHVvQp1YixtCB/9uGLvq8EanqnrPNZ4JeIJcSd/xyYAH9yU57U9YtSNyAvFu5z8YrFbeWITMKJ/d+s6RLkMtdGB70quGKzNJF+9B9vLrdG0q44cgbPlvhPYvSTyL0IykR2RZ2HJrUyrnWbsQvT7G/0f3LBS83s+tGvO3eIBSQCw+146bqwxNOOmNz69o1PNNym8sD6VhyvFRMr0GArVP2YdJ5x9rZxO9DIrtwJRzFckhX1ctbRz50HvRYOvJiAzhPtEhheNRW9DDjDOMEnibmTCmVl0UJ9QAqzwiQ35yeTNOUzzIjClgSJP0ZL1p80ITUdIGWT24ZEksbjGhb/POOrzkT/Lzupn+HNrvqReqZQKuWB5ys3q5bxaR02189SxC/xJdGu7v9y9wiw5wOvITzDlOMCXq8i97p8JKDB5Bz1XM1YSu6YiqpKjEDLfwBHvT3z7660jrCk5uvyI5nFWNLr08d8Rc219gW07lgnxVQGIXGMqcdgf0C8ptYMw10EAnRz0OHW8vgYoxpATWw/oBOO96nraJMKN4GMZu+b6S9sd/gGyKF4iKQKJ0xlQw/bt5Hwozun9WAWxvT5M1KMF1ubcTv7RozVG1hZlSmnP/W9nD1MFZpJ/qt1k2SKOVVDUKn/TyhBhPlxRDFeCahIJ4WhE0baE32q7WOe6SaZXSm+mzYo64+v4YknSS+1svixZPeeElC848o6i9NObSYVZZeLJLmkFcFX7BMbFK3/HhLoaAcVtS6pglUUNX24kHOapx4EDEb7zyyIB0PYKcSybX67T0Dvw7VrvZVM3Dmrvawvv9MQ9RdklFG+SGWHFn9sJc7TioE3fukTUriKV3dZI9ck4b5nLSEacVRCgLyOqvTcrBCxwAr0HIryiYu55cOkYrB8/2EHZFDtaALqaIhZHt5t/AUiBs9BFewhfsYSSidPrWlvQngJJUkVsP6rBq1Q3j/Svc25fM91/0Eo8+0N6seeU1cfa6BM2X2AXwHBkdKZZDZR+YChIXdrm+7Kk5KLkTPkSr0+96Se/vJkGuQSZ3e7MieaNawnxatTdeIvaXvds/FK4l5hnrFBueDbnwMZBWihcKGtg0AYGILus3kQO1X2hzliHYxeAeOU3sAnQgdx60Vvf/B6fqKqn+PFjauOVsWXcrXUZORXN3EIRK8K83PDT/HhwgKDDJ4faV1JJ+rXqNfICaoAoElpjw8GlZG+jaKlHon/du+Jdap/iBdan+2gppHRCHMj+WaCZtvV2AUcf6lQ5UTcoCWcoiK7EkOfGtqNGV8zhehc5/wDB+fd82ueY4rcsMbwjaY4tbxhhyRFQlweaSPc5FPjodO3SqIhkL69L8EPMXs2KVhrdlFKEfTRFY4xpIq/OUDlbodd5+OUUq4clIdWmXbIGJKH7DTtqyORREprQ+rX5Rf57YakqDhm/lw/qgFMh99uc/41e0JevIojRAK/n1F08zB99db1cizXANmvqlxllWll0aINaF7esUIYVVBA2bHZ60mx8KBa5k4Dd5zqEGRiSh7eCfTmA6+4p+WPmfPNecYBqRdtZlLCHG9YZDZ47t8FRRe8D9I39KxQV9T1NkdkZxXQ9juSHbGnot/HTzOr+sbFUDSyN0fOQCKjA96T98IPuGusLDvl3UuMHQ+kOv8ua+/+0LablnDJq1wHjNkFgMIRnRPS2RqMyNIQgcJNY6KYsKghnESV1LC4RBBMolAcWX857C31oaTPxqs5CNB+fKb+cgMBSEsDaRcR1lEDCEVwDPRRRiyXLqCz1moOEgr4aW9aweB9MfIm7vk7Y7w62RNF3cT1L1vLFJHYgBkJoOvC074b48jgqBj2kjTgtl3wsNK8iiQqsaC61Et3bpk4A8J3pW1ONxM7twI2vqrkYPq7WgC5De5wnuiUSL92OVdm6wGdlT4H27Fg+HJ6n+M26HnBQxKaN9wEHorbgYwHqqLs3x6J0QlHFZOBGXrDMdPrTE9quP7g4aDtoNimZYT2JP3jrG2WdxQucFY8irJdGvQEoy22JvkjxjKfBXjdP9AnfI+53VoVJZ3YoQDgJUBMyF35tvjemjZHHXHdWtR1e5jYGjFl446X6UX/I/abtTc5ZxzhRyteG5dbD6vg2sAVy6ubCt5lJscM3J7ZrlULxBGg0m55mzlXGDNb9+hqcx2mqoAPFZc+vygGEy28R4bbrAO1o63jLuq22DJ71gDQnuzMCaB/qn8EemmQNy/fWM4Fujj329KasBj3jarcH1y2BhaHxX9/DppvP+5kDbxveBjetZfu2dU1oCJr0ljiW/PPcBnDwbGReQqPdPN17NRZEuLwFppRdecaRA/CUdFTBVux3N/HDKEgQhJ3ULgIKP4qdV3KeYlcKIWItYzX4LjbpIrt6EkEJ2U89t+yPkG6xGJOppY//D/CD3VLuGOtFtVXfuPyDcWcm8Zfl1drj2txwMGIzRO20V+NB9T7uSzYTnYaoIHKWs0cGQrBZcfVYpfYUHCXIFn+Qqxyfgwn2FWqUi1ZnIh9M7SdDNiDIunqYra2pNKthvZ0AIJItQsGg2FfQSPgQ7m5Mfnkr3CSxFNTqPC7gZXSPEc7FU/8lw8uPcHDTcIm9focyZs0AejMK6uVFn9eF0ivMm/75cCn7ICBgTMHL/hXUvE8zz3W8j4zKNtru6/AhAjnKqh7VF5Y/9kAAQAaAEAAASMAQAAPAQQjAgAAAAABEQH4QAACAAkCAQEKAgADABlUaGlzIGlzIG9mIEZpbmdlciAoNCk=</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right MiddleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>78</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right LittleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>47</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left Thumb</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>79</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right Thumb</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>69</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>9</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Iris</Type>
            <Subtype>Right</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>100</Score>
            </Quality>
        </BDBInfo>
		<BDB>SUlSADAyMAAAAMrsAAEAAQAAytwH5gwWDiYXAH0Bc18wBgFhAAAAAAABAQMKQAGnAT0IAAD/////AAAAAAAAAAAAAAAAAADKowAAAAxqUCAgDQqHCgAAABRmdHlwanAyIAAAAABqcDIgAAAALWpwMmgAAAAWaWhkcgAAAT0AAAGnAAEHBwAAAAAAD2NvbHIBAAAAAAARAAAAAGpwMmP/T/9RACkAAAAAAacAAAE9AAAAAAAAAAAAAAGnAAABPQAAAAAAAAAAAAEHAQH/ZAAjAAFDcmVhdG9yOiBKYXNQZXIgVmVyc2lvbiAxLjkwMC4x/1IADAAAAAEABQQEAAH/XAATQEBISFBISFBISFBISFBISFD/kAAKAAAAAMnXAAH/k999HGGAedHIaCufI1WB0Akvfjg5JiBNcaHvN1ooOTs9Bxv5vtoMmnCVFuEtKbF8I69jxK8D1fLIKj6dHiWozNQMn+dn2ZXgl/jaxJ0KDgHuBhFh8Cw2+KBG0gbCqwqyYDNDK2cO0Eug46VYvwjMjK+atIYWDyjNQXYKa33BlqRC84H5kfAwUXyV9k3KubDOElfH2NsfY7w+xuA7O7JEUho35vNjJrokS5zM4GOdxbMHjsWqUkIfJkr3BjaDDS0kfmk6iY9F73PCJRHAVA6GK0QTw3veU+Xjwr/Fd1v+iuE1WcpeKUYNd/BPgyk/Rqil5/ZATpApLluFY6p6cDWxFfT2h+jmhRs/JrPTLZ1kkk17DezpIG59Ymtf6hN1SUUWuvqGPXEMRqICwVWzvf5aGtQ3Z5ohoelAWL8qb1ZHbuLHArHglWrqhWpOmvmYF/HRuObnLKkjjmUyMTFyXZYR+lxvaUv3y3odq7Y8TN6kq0XVr3SbHoIEJAWY9ZJOrE8r93p83RRk2eAsm9BxMC2k5iade1w8jihvXM8cgXV3DS5q8pq7VoutYILYTyV6mPE2yXihYae+Nx3JlfWS7EC2auMRv9u8LwYYYC7C2ZhDljYLWzLizcv6+E9LuCKfv/fC0gQya1+TJIAOWPyH38fZrLH2a4Q+zW+tkyhedMTJfHbsEdeibsG9cdRL6lhyJrv62JEkGF01c/fzUcwxEs4SE+XJ7Op5gQzPXauPZuh1Eu+n/OYA0FW164ORbIEh6ndcvwmuAK/6s8Jk0EP+lusc1PQBznyBpMkKhRap93uyBZmUN5WjFX+qyJBFzP3KkV4/7uHFuTxciy+obKMLtgmO4R5srLy8SCUVVvZgzbEgznq8LRB1UYxXoJiUIPZbhdLl2yhlzmAa4yiZQt0TNej8w23+962krW9DmcqKfyQFvlSCqyE5xS0Bsis/Y5Y/dau422K3/Gy5UTuPseDLg8aQ79hbTWNhIXyxPxmvY2aKcCcdIcYCe4meASv3Vuy/9GPNZpYGqiCABYPyxbOTLRg8Bmnf9Nfr+VzhbIlzweyngxGPu3GOuwQNuSVwi2ldL3iR+195cbHux8oKDZgqPitkegxF/OXvflA+pD/qRpi63zB0GhiXVQCfy2eT16xJ8otyGquLmKB3FK2yBmtRhsL/gDCFctVRXbVUXKxRouHzR+dcoxVL+Q+mOM00DpJc9h3xr+aDvH7WGq8/F9h/wLxpU9L97K7gmnQUANhZ6n4Tno1VHpU3NeKb0hV7uWKrupZ3DeMkq4rxt9so7dYva/g+AgXBtzE2GHdoxUnUAfpMxhF9bGgGBBB3b0VhCSE9yBN3sHtxDSWlvEtvm75gGJ6vUU+oYa5qBNF1wihhG8FuU8DWz+jRmhWcmqhFaNiXSBJdFWiXtVg4eQXqGV/s+pz2+1rmW15s2s9VMr331uLRRQQkITYroG2rwqLVLU34pFIGWbjBHtO8QT5zY8ZmfMjAQuIrSszpflO3jF4tKvEOx8ofipNDh0d0+lc3O8eF4ZnnvqGbH1rJ+GSa/DeJD5XXU7SzZKfbnsBVg69FZsbTVdHjrBN4rLEnZKbh2z2mm69FWXJnYENciKArpjDMe5nUbNjIUJQuB2Zco1QxRAyA3PyHlG6ajXdUjeznQKtjC50hfBgOpD+xXBHgNv35D3E8qK1BpJPvECLKrCWLvGIRByTI3aqwwhhTnY+x3gj0de9ZLFWBEsTZXtwZf6lw2z3YiynTuJqsZ6Vcn8zLvYXPTOZ8udKj82/wuHJno89pHIzuoKS4eaFpmHc1M7FEJtWNZuyu3Lmk2N8/L05AlOucMXi6H1p7riSPGsV7eXi4B2vmFpZD6yfoTMwI4TyCTu+YGnTq8TT8cGSibJM/5PTrxPkFHKV5U6eviJa+SiXBrTPw3nJ2XP5jDCDFgNIb4xGXSJVd7LbB0pXbIdIy/1Ln8QqC2/KdNp8CsI2MDIA0LIvnNf1ev0yM5/oJOwB74YyxPtwFwyNxjF0mzqbLderRRtYNwyZwz6OxdPWNqS99jZPa7KeXuqNK+2avsZz9+OMRJdT2l7M/nx5hBOMwrv0ZrjqxPOhFiEc7asP8kZKEHRjY83RpfGXRr5fNIX/H2+lfH2elnH4emcCFTNqBm22KbHoYAh3pFNYPQfL/ESb5WjcUDZiF5eHVSNfzvLGPg3HCrLZLf8ejG2488nQrhjC5VIJNLLGwnrwYBkb3dAi0N8MKWMLMuQePkA5BhW54RWLfOZPxFSK/2Z2XSHmhu0VLg8FJXFVt9pn/MLfI7iTWMGiicxsDcv8O1TljQ5aKnU5iMSMYYpYWhfxqk06ThCXug1Q8X8BNpYxWDQE0yGjBL5kiXMAH70IyZPYIhVVv38eapgyrioMwAsqXofW7tWkr4S/0hzojm7A76cHw0KdlOpCh/zV8lRgTitHerUatUTTiV2Unvzyod50upnb7GonSFK8Ah+1bodhgXLIgE/0kwzSi8ddW75vYyKbCzxLeTSnt8pvQqZx4TgcoNmS3NiG+6+bfFGLrrCE65d8sWn+kQ8ZjxFwcfKc7PjypK50H3M8aezf7XuXszwtdAY6nSCX3BHy3Ka0MUXwTrHtr9sMNV9OfMxRTE4X+EZTRLhVn/w/T0sKxhA5EOuWLqxOfjxLBrSFZ9ZfD6vDTa3ONucpr10FFs6AtOuoREjO8zEKScmbBxMH3mw5yFGlabdAA+rhQuDCX6d5wJytZ3KSk8C83mserh/xISQU0WYDLVl/cuzW596HMP1ARXrRmiM2TaLifzxujzQXYb4ELy1vLwZ+ysgNhcQQV3sKBmPkcMzpp0Dljk4OszkaUUtbNoK3e4SMyobgpih9VunehjKBWBZcrTuRtdJl+UOVdHwfkbukLZ/4M1UbejTr5QxR1MTMhyYdgfOlLd2V/Ak8HZ+z8avj4IEQeuWS8RGfBJc8U0LZDNPkHnlsGm6BBci9yccz0ZpLGp+bBoxyGN1Pt9GeRf/Xy9keKCA9VniqaU+LBg2p39GJ7EHjhVYD47J1RiSHEnQ61xoKG0fQPG5kouURYZgYhfLSu5ws9OMBDjak/fOj6dQ0XutyY4nCkW/xXtVcrsRcm1zy2PUR1C1eXI7SggkRAFHWnRIWOb7qCgPmjbdPKst/XngLw2sDe+vsIRcpatldeXeEThp2ehp4H87H3WCkPh4gYRtNYs97iRYpP0keiqtw5f8mbKC7WlvHrli9WdiaiCKEp9FRyj3B3Ks6aRw6K1FHsvRTlz8237awbHSK78pajcqrRv6w3vj7djgKNBwhSMoZqp0I/PYtSkAhKTQoKX7Huj+XjXhzMDTR5M7pL83FatUo44amoH/jtbZfUB1dep4L8SYXenMJDn+z/XjBhSM7w1R6s9HWjig9accZEYeQFo2N5qPZvoDrghq6culkkVczdUvvVw6aY57YZLEiYp3MiWbXsdPQIiaOBf1Mg2hd39JjpkvUK1FUaIY0PVLh+hV/ebPMkHCaEPPi3q3teDraG3NWPi2L/FGl6P9jNzOhyM8HX6012tld3FkjCXDEF6ieLQg9wnp32mokTLUWW08dn5vnPh2L8oHLrrW5YUC3VFdGVZ1U8510m5qdU+vXEK/3nZexDwg8oED/Nz7/uCdGILj8y+v3W/wAMdMyYDYMNrIddo2GWI+TisMtL9jlzSXfPfGNR/XYDskYGOo8R6InluPOd9lkJxODPsOadp7C3TgFstl57T+XDjoJo8yWKC0HQPrdoOFn0wVfcG3KNM+H7QyIXl8X/c1/6bwIVthgpiywSijKaR23TUe+5LL5GmTYNRUpQyedp+kVhFBLMUAqcL3WYSCGmaei99xpyHMgahj2ttwt7KNp98np/FPuB9e0CjKQrSHtoK5ldWvgUD2LL4sGcBcmA5RS2EqzGQ79/dV/u28vO3M5/c9BM0sQ1CmmSVYjkibbbAJhYEMBzsVW8m3gwBwvrpksukrO+OUo98ALC1xpMeIVYSLZaX6VwMeWJ982j5xZWVbQ/1AUuOgQvDUEhIjfevYAF0ogk6CqWNLuWd9pjxR/xWngAG0hQZJjETBZ4pLWN6DMay6/bZ7cv/qyQyNB3RRnL9CHFcpTwQvfat+/KhTpju6hU/rC93Dbr4FzPLBvaW5sBvS1WnhayUT7TOlJXXzKGd6cvXLXtsIOgNoFFovcEyMm0h0psXbLis8XNo7UF2Vx6tWnkcoZ1RZpY8bWpYRG6xC5jgv8auekK0kZdZZ1/34NPcosQRFCyGVRjBdSrRqfhlSj3NkaRJbUTMtKLjpKPF34aikn7MUmQGXS7Cbk4FCpIbYZrNaJ7qudgEO64Hp7KDh1cbKW3ogTJcVyFSSigsdo1ZtlaAQl8yKG1S8LrXiR7hFXn0KHgaa3uPvhtaucFDaMLslaN3FqSPoBEHW0BPxY8uuG2AL7UEGnYL9yjtnS+EyD/crN4osRbsI2FVut5lQh7nVHCzpqrfhN7E10Rrmf+RHC+mzwPeMkNUIwn9RQ8KFLLNJ6+vZ4KpK9lvt9/MV6UEf96HOQDPc4r4xjOTUpEkOZDLHheP/93nlghf8PwG/DQ0hZpNfrQhHZQFjb5A47GfuKU9H8IjRwdE+prDB2G4oAYe4r/ceSCSjlF0y6GDDVM8n4IelRdCJDSn+B26leDMwDEdJ5R1s4Q2EqWJieuVzR82SQFNnHM2E/MKCIsh/Ep6IYGqLNmRLBN8MIDzFbOFLVW1VSnuwMFrNFYhtkvFBvt9W5cRbjPtfI2cuxKJzklLpFzpLYHNvcJP6ZZF381oiablM9+mV9sivb9fWd9f/wh0enNR6gMy/8bVD+tr3l9O/AWBfCKBChqK8ehZxs4oK8TOaXzkYGU9M0f3emseCR/OSfmutvlIN+2AvPjMhTgq7bIE7LzLA3LxgdaVUpA6IV42CP1Kej/Q02JE/9JxJRLht4OhbfSiChi8lDRxRk+XB0CLyzZrRsKCMntzlnWkac8KypNuKh2AHSiC/zTQYutRgZQSvVjcpju9oQ6NWO0hQb/VfZe4iwcXQdElBGJkVNcU+kEY2pz6k4Ozfnc7/Tl8GdvYtEI9s/vNWUvyP9Czok/zwoXoP9+MiRpciKnGaD14SJ6V30+4s/0PGQDL5gLTty9+8QrtnGHcHlsyOEyXgt2JV/tD272pWIWOxL2WdEqbU73iQ7gXovTDGq5QJIHOd42bJaSkKNdRfIWSnbNUfF2p6/VbTPGD6oT5HhkfGQ49n2x2epiUjJjO4CQgH+tknAD2+J6XtOHLm7GvY9jtkP2jO9CXdgM/2XH/fIeLS5pA6bRRiEsV1hujNtXM2N1bduTijh5JAUWZdNp2vkqN5EXKzq7Tni3c/X6uMjjmq+T2otSsBtxbOufI908p0HsMsCWZvQZqJp8Fq5lpQH96ewjmfOm1JhPhyU8W234D84IafLj51cEVc9w81yyB+CMLoTwAKPFWqGIaJVAUzZjI8uQtE9/XBVR+W/aElsLCWl4W4fMomw7dd1WT2oXmBkUl2GdFOoYpMso4Ot4THqp0RKEWGdPIAJhDZwkXQ/6wrC3XOAD0v73x3wbvUHli3Rt/F6XYMhm0/ARvBfBAzzI3vsKUS1fgQb/NdCcnTkR/mtG800XnZTJIxyMiNETSiNAbO0lhin3UNRdGW21LVdbujOSMG/a59aeAmdxLZWpMFBh3xukItBxzrBs9egcDdnY8o0o3NNU0ZoCLI+Fr/ODFZOACoD/gcOjOu/UOjfEhHjxghvypnrN/dvSag3JAkV/pd7dtXyiT+BcWyod/1vNwK41lQxiyDIaKmZaaTxXgDRO9E5Tf96hJYhmsZ/V24UGImbWV37wYhe3KvS5EEZlOLROufZfFc9WIRtXcRuNr9Cd1zAxyKFTP+EGJo1vypWdV/QNrg6KNPPW0xQ2YDQFqjDAIceWqq5pC7I7D0/fN+MTq4qsxYGns3aZb96TzYE3/AR3XUh8C6GTmm3Hv8pDJQwQkPTosR56+W7yFjCh0NqXntYt4Y8Axh0ahE6w9Fagrv6ugOYEC0MkE9hDpCei2pRi3926U8QsJ5WGQnOEz75P8YZjhxzuTlp3qcUqTC42uLlz10YPFIHyyo+6DhqRwQxS+ejm+WRORm7wqZmQYvddv7kLkUUYavxFnd4y8Vm484ffvXEN/fM+0CmBgaKf8THqV3ARD9QKdiRG0nFO6beUMEs7DTifwceBwGQBezn8+QHtaqjvUOjItgtm0LdUl/46wGJMdP3M/aLlHawFvLhqp4h6Cbmfh2dUP4fL1lm7UK1Mhf7irkjkQnPWao8GyvZwMTkYrTSN0qqlqGEG3/vPbDltBqpeU5YScSS753b7vsN7k/3kAkwes0cKCUKcIfAic1jgAZfnNGMHTDcvb40clxG4xQ3/JanBw0LGBeCpZE57u8+ZvD40haDPAMOOlU5gJGolYQUgFBs3TwdcEkaWoomFVPkXcaOqR02noNNOrwfgRWQVOzjP5NNHrTxESsZzPs6v1rM21Th+tHSwbTiUKaZnThwq8hZifXPqK1YCQNX1i8G2F+1STy+SJ5prMlbGa6tzszSBwcXI/zJLEK+eSU+UnjunkaxZG/0+cNSIcIUiWNXB+dfaLOD/h7n6R0ran1Y9lD1FsIZm/yYvj88dGTeGOGKQUDQnX/rucUQbnG2Hbcyhg4c7nBYR4WHqLCkKVWnZgxfPavHf8GXHIyIhtpxtCIDaX3Rn6AlSv4mnJ7Y/CoQqqUeN0IoybrC+UbncGSGBmb4Z/a39zBuep3S5zjfMYbZ0cDCeVzN5AWv8DYiNWYvvvzPK7DUTvTRcXeqTvfG8uICcQf0gHspKDGUX8NDzEndIJZmDbHGDo65cjvRpEjxm7AFxchU3maIHeb6HkT3FJC/SMwkmvL2qnhAJk/zZelPZLsQbfPA+C03xnT3YmRQQRjXscb+WasbvjOJ+etxQQxMaEvXVB986dFSp3Ni0slxF0OP2/Qm/t9dCPk6AT59yY/b9BnfT9ZePk6HX1X7h+36GT9vrwR8nQ+fPvMD0TpFoiumwApU75b0ZBodNzuHNMJ6HDZkubjKwhmEetpf/XcsNnZvM4PCijZ1i1N/JgWr3VdnIXMRMBUQyASuXgrTvH6VZqdL37ryDt/17quEzV5ZX8TS6c5RjyxqotQhKrozu5FlCvC6XdXPWuhGgVDyNUng2CmoKU3AK7iNZHpiuShwRATd1MKAqAWO6M9h3JiXSM5rvokclm7nipLM0++qvUlkURpbX4Ag5JP9MmeI6Ye7jO40WKiz+7KCa/L+bcnXN0VVwhr1FN/xlpQbbbVopDP9oa5ZflSyYg9eayfVD5gAyboDKxj/MEJL/RhVbuc08X7KGlYEhwvZvYaBVzOUiCz8rwlANzoIF+Yi0oXCTlJyf5zjWPKf7zdJ8nnZN71ANCTF19QrCqdtb7FQK0cDi4XeZ3oQJ1N+cy3PwFnYd4AFF1ioyKwYw0I4IFmaRaAt1ymA6QZzh754cUIPFtC8P6exOkZMRz0f7LyVXuoNBlktve1C03obAIzGeM3qA0VBKVL8dhZ5fB6MtAFH6Ozu++BtYaRK7aBO+4giMRcV/5UpTDVsyqgJFkucBavkQqxBpWFttT1no+ABR86uiV/W0Y9Grt5ULmAi22YSuY5z4nsbqAYQPvHILWyLyF6Dy2gCy1uLHCJhiiHCcp/V15uN0ierwzz7gxlA8NZQdFqwjuXuj9pisv9ZjQtg+7trYkzUykdx+dXsrtOSXquDcL7Eh0eqkycFcWOV/SQsrqYeSzHF6lQ30qB1vTmG5Zl53CUVETsizwcXHlh9o+eIs0TIAhlo7/h/Sd+54qywfifydIMRv0ycOUJQKybj0g5YDQovwkAQDWAxogJNnMnAgfsONuLp7qTxM3LsGbOm9EhnFxwZeiZpGigIlqNRLM4tmAwEhJyWtEihL4ArXAE9pVNk5VhduIcdLKnKF9qXvtL/ZbnOfmRztcE3B6ZPxmexuSYvkLKJfSpIO2JiF4k+vQlEWhlG6wtrSmfp4HlGYoywVWMhjJKojxGsxsjNnj6XjTX5dcH9HOKM7Qx7q2BwjeEjE6AyAae0K4RAGdfYxp/ImS2qP5aFlm1odOKHthSfmSRjowf8/3cmJFZYH3/MPQLMrnOhlbU93QhrzzDX6ddqlRmfI6ZPtOQJD2GIe3xO4Xcp2wfgC48tzfk6h5bCmRM5sASDFuQSbHpfUsFWUpccQQeCb/NX0zOXueDHf4ZUATKB0ylDqx8iDL8rY4+gYI73ekNyQPrgDpU4FKbjL3Z4YT2WWGrYml/R7pBLFjs+V5N/toD6NIrVg1Zsp3Ivm4vIZG6X9kp5G9Ib5wgZrRQmVQL7/bUyXQBUcd2hMSfYqtFclmO70ff8Ilxll8ktzsSDq4yGH4evIv47/JAoHiZR5UOg29q+Ssr7FvAY1OhrLgJG9W8kEaQzEaxKVvsGiwyLZs/8MSboRLSAcRko+MX1Mzmja9fz0INbrtiTz8E8tiTE+ERkttvTCbOlr9xZL50thbYk8hskNLwNLj98TALPIRFd5XTfjubd3o/lh8zqJUFxEGW7lMVptq2HQqpj+phK8CLJi6lDfeZO6gbErfutl5ngYDFgA5y94LQhghPVaSUzlqWGzqgyQPqV2jG4liE7/ReluGAN7GT9ll5yswTCT0d73x45HwrVl4pAHKonak6c46vBGxZZiinprwZbnwm+RyyyL2RfhT7eNGqkbM78doH0R388uUDyInE6zNInZU/dcD529E7qDA3G8ppBmzNLHaaj7eTTUy1mviaalRHZXn70vaUp8VSYfet4R+GGrZICmi5Ya9Gni2j1cbCvplsOxed7hE1Y3ivaitfVErn1/Z5keFS+Da98VDO77lGfPehiYfaziloiC6iMvc/CedMK3KN0bITjPjviHR+jJv1/Vo5MbUHO3RHfdgYxoQJP27Pf+Ptf0d8eVWXtxXnf77MTnl76owru18AOb+ZAcvxfz5aBAd4Txj25hUX1lQWOh8rIRvTBizOy1CUMfRI4xLixnM/ePeJOEIUAArgvfnyRhP5kcM1bz5NZfy+w7SD6UWmKpoqgWAQgoWzRg1uTiNYdZyEatXPe0NE48slpx2KeobHffjCJ90nMfu5YbVFbspUzilcda6VYpNPA2Xp/H/KvID6RJeiSDB/bSNqOGUyfoX1GUOC6qV13rkrfIlvEB2O2pl73mooJFGb4cnsvrDpgLM32JbSlJLUBQVkgamDCuvgxh+dQR3O4wG72GbYLe3eJY/1K9TXe4/NT3huCVaPmY9RaWmw76iPXQnBD8yWH8KI8uK30wcqkkDiXZBvYc2HekGHAZILPmfvziuR5cg6V6l4diy2BA1vUtZyGPyy0zAej27hXUMxncKxQavr+FAIUsH3NjV5YFFspYLXWH7a/f1rXrbA/Ee2swgVplhadyQhCOO0BJ7q8OHhsMMYraV3iDWf5kaIfmxVwQJP9uB+2EAx6MIDlVTthbfNJFRAZh0UWp9I53E6Cwpqz2k/3+kGPxyaXJWhcmNHjcLSkvIQFniaVE/ZVNpWFKRAIt+fPF1e7aRrC7ehe0OidCfcXKwSsOLhl9IuVsSBPITTPC7dd3HhZKj/ydHfo/TJ2hJZxTkvnRR12DnkUQDLDOxeKlj5M1UVAjOlawIEj0dfRXDetuvPoJUAcBBExO18wUGIiH6cOuWQBd5MJACo3wpojg7l/BkLcVPkITj2f2GeM9sR9BGmAB8JrHOLHUtQfEfFpGiSdCuJoIDM5eHOxpXUaB70Qzl57TrZobXNvu8k+8GW8Q4SXS6IFkKxRzRfFsKNfmGVeTXIgDgnC/YRaSHAnpgHTEgcos1/RqrNAPn/yxCaOf9qXjIn8cedu4RgyNlu6Gvzsh2YZeI0Zi6l6HUsI7Bpan2gKvJaMbtHKJpjksbM3klrS2vdqauH/hpzthPNqiiOuIwfQEjL6aynD04K9gCZyj+dk2N07qNTagziuRHdXuEKwr8thEHNRSfM6Y3f8GOOysh36aR4/uWhO1RMKxD+Jp5HtTDVvsDsCddBJVYXNQzJFTesto4KLPDdPQTYQmThW+7vzooT5+OZRUFhm3e5N2Q7MmhxxYI357bQAfG1+PQaleWn+Rna91LRXI+0LbFU1O1084atBIKKyI6ckFTVTKf+/TlyMxq/oteS+dkFTy/0hGeRGsLXaJRLjMooW8/41vfOLECQ+PcazyiZxVO4EAZkRIZQKaSk2RrKhnMKFM+U2JK8GKNYXms5buQbvgBntSs+XfXM1fLxCaTnXBv2aPoi9pCmJLk0g9CPOXCrfapw4T1PKse6AzVkIr4hB9LwdSZVlWLtD8drn3VlHsIy0wvOV8xUjfk99q+RjUkMkTbiVS5TnU6MVXOPEByVB3oVmoFtpT02VmWNBSFn+whlg0qdJu9A1wqfwTz/DnZrfD7LMtJ43DsBRG9zi7FhMRmV3ItInJoMc71sW5dlwKpSfRtVPaY8lv2OWLMu/rNeF7yrmS8+6Yfu/YvcpzeUBgolZ/HRN/TvuWubnC+8pgHLJbGJAqDp8uV9ce1upDtxQUhRgBEn/rc/5r5dFDiGA37pHGvOFWnOMk4O0n2iyHVvFE0cw2FAwYPJFCfgAtsoXiuG2gyd471E/8aeLk2e7SqqUQ4g4eLGCff7o9EdpZNvqBkBez7dtmj8h/L76/u/YBKX5HZgNF9c5plX5BARHRROFU40i09Evi1XTislXJpoXuNsi+JqYeEe6a6514SqdPhN4ECKKcmrE9tS+SVyEjjMa5VndOajvwJ6E+uoAjgaBz5hqaGlRvJyl88V28Hw/eaROZMFz0wQktDVkkcYuwzpzVt9DHfUx6fepsRBo56+j8DOx5kYklxocNaXYRF5nqEiqC0ap9SDJIwe4Igyj7LbEjwa3/eBWYH3U7UdqqL2s9tSwxThIuIO8cLIPdAn3pA4KzLWCe71lHCV4FIuEGb7hLWrjPXgN4+JFbvFMpQ1fsfnZUgb71HHgiUoQo29tyY71xQlgPksgMxVlWTcn4DS6NAT3+teWiZTEYFYHSYuzmeTVKhpRlRgQJJKsrhheHFTMtZzfBmQ4uSXVhLlnURRVImWxwsYYiemXHMCnEyPO1pKBndYWg5QOj20nsZ8HtnTLxcStJFOBs83JkogfRmwIiYdIfNAP5jwEVueJ+VJbi9WjmBAh+/2M6FMOByio77eXLWs4VQydcev2GWXZWnYRlXHKhve234BRCCRY/C3bgVXSb/eZILbBMMM1AxwnB9xo61dDcDLMD+86vkmr4OZgUr/98eAANvE7W/hLpknThIjkD3CopUuezWKGqgnizRCmRlFleq959skDNXm8cktJMCNPmzbBXg3UJe6muAqGE6cYzcXTDVV2vp1G6lCIg+MvZYkvaeGJHWtXXR7WgE1AsmfED+MQrSC6se5OshFFiASIwqxFtN7TsdJaVSjmqvWQGRIfcwP5pRjBxAIfxhfSnz+HgamauX5k3ukHvRu5NENEr8ts5VJ8nDIBMaqt0eYqLze918NfG6JF2g4Cg7Mfxex7R/hulA0Z3tWU+mC5g6M37lXHqNcJW+6O9hjPKrMEMMMydr3R4FvnxcFRRr5zFfck+hJhV5IuRpRNTGNDs+/Af+dDipUGnZz640ffClFaPpeQZ2huRbhD31e2aBFu44AG60fp01uvZNEjHmdx9vebZ8AoN4d7U+5FC5UX8WZosVj5ovnk+aqJfz/QN1hscUR1n/2G8xYkEZyCtvpHnAeosXVhCQu2XZGT0JkfyCJr1xy8+ULaUETBAQHSC6wmPDq2WTKhxkaEBPGqY3tXB6pUmZR8FANK/QbslHnoN1c3SBIr8i6rVo7vWqeFQ737648ZJZu3NJwNEahI7mF0I/BApPkjxvs1LCcEwtdXAEn7cvNxlLQ9nkKyiF15YMol5Bm87xRZcfei+2tbkTKIglMuILoDpQZq5ejzAAwKmAxRWGlHo7YhpOqND0G8Ty8Ejs4dLGlrlAQD45fcRrhQk97FjSkGCGjW/rfzIY7tADg64WJPsJoFDT/IW7yIGO3ycUMK5S/xhkJInOTat1Rs95UBhtqAMkvUyKvtDOhRf85B7NBekyX7iDX1LvOJWLbHkeqqo4nsCC6Z8HLOSuJi8zBiupMvKZC0ejWxL/Wi3yJeBC2TVd2dIA9T9otggwMcU64NLrqRzuXTFutwRPwk8f3LIRj6Or5v6+jX3NTaH/frLFSCHPiA0hEsx8tf152Xz1pQnDGXVRtogwDGOZc/0iA39bA6p8iqMxIhi70iHnLnsuDO1+DNz8X/iovqE76slP1/UXwx3/kT9N9kblHarnPrhIk6RlGmu61wMdJSAzt7YdFh58bFYfH8xayWLYRQiBNRPYI0T28E+7we/6OGo1DLaCbxptV6XHqbZ+vfh4q/HDKQKkktSpullkngCrZIZH7jAg8CTQJX0kHjxWGDgD4B3Ykf8qXdDmgZZf/RWaQ/H49EpI59Dq2BrgMeR7iH3JtLUoQFFgevxCFH1yG0L+4IeODCiRMFjheBvmdvpIsY6vyegTYXMTJqMe4Ab14G/a03AB/MIIYitQc9j5VLlKRW4JC1YjPsobuSjUD6ePYcsU+jYewdA5dflcweivkG8U23ha7ZZhcNJa7+gG81RN4Xx3eCsPrjGtBW8s05fRI+XlZeYTDzYFQrdOW0wXHK3S5zPN4cUHcflv7HydiZMo+M9T+NH0/YTrPQHbEUxpPe3bPShuLfF1gTFS0pi4Ax4A8GYQEx4bIGdO3Bp0EZdX4ZTj5q8lyaI8yz95k+mny/8MaIiWoOlWbDpLOyfdHgLoGQb5u1fKUY0NB4/X+cyNsAy698Cb22C/FoaFr988nYwolSqy/OuGK6kq8gnuQXFvD0REfXYfRCD+7StQ2CGT1C0Gv1LVixyGuhIJfcoM3J5C8IY2/Vd4dI0kjNX1KnKn/AGIbUYOLuejOyO7djxVSF0E7JB93UDWIwkMFzjc97BmyJps9ZFbz2aQ8/h0o0aBv51zLHuZeBeGXAwHpHz9okx3WFmU7RhzRZuSIQlXGXcj5IpDv1TCk9nsoTJIzByR6xburTEoCdJntmbvA3/QqThbqhZ/xW/rY6xEZCE6vQ/JFySwJiEeE4U7rPQk4Z8Sfmw7F8Nf/g6JVvZTfMn/cmRe0p6tU/w42NY1Dah7c7dVA6iHtdZOAmqxOkAaBZmSRV/umNGMYewut5pmkmvBCs28GG3+/apCsTh5WQWNzZ3S38Hm9nxEwC6jqJRElS//A3DPquzxGJdLrabtqvoQvpRX2R06VJHze2VRW2g72aD60qOFquSgQupml/qbQMdJE/HLwEyif9YHzXjJ8sH+Oudx1Xj9l0cKWfE4N7HYOHT9WGWlr5hJtjUWPsx/wQrqrsl7/4JAJLigloyePXeyIWMSBRvFVJgSCg8sYwi+o3hGHYLZJ06y9rdDPv1ScafaTyPPagNrrnbxiDRk4vN9SFj+63A2LuNbvGUrMCQBN4C5THiKLeXh3aS8alqSNQJG2PI0vSnEp2/pAoMMBVJZE4AbWigpcrzPTJTTxiDEeLa7AZ3Yt2tB8hs/2P2L2CfGDibJRuzXFTlZDRlPOqjM0z9kWyfqOUSxXeaCYQos2UtLASsNaX4J1mapPJGTe6VspTAmUiO+NLTAq7sZbfb3LY6AdkdzNyQj6C7JGBWWY4Nhr9rSTYGeDdYMoAjjAWfUs6gFfLugRrmbxnkdDIS8WK/K6VjwVTfchDittKvPduuV7eTe/IfYNFV0Auy5noK+cxT2WeQhJUWFNY/fQvrf9nQdRB5neK/ovMm4xNb9qsi7qo03tkBwrd9XcwVFfbj5KO+P/1Soo/rpv7KbBKq1Nfd8hsjbFkcXOgqQNL/HIEvz973PY6YhlGwXhks8MgMEvMXjrIeq7QXhY+myF519+GYVZSeU1/OrrJXiwentgzuJpAwcN3BvOlixMLNlBZ4F0Re49kuHe0JaDUQivoJXBWU76Duf5OgDFCjCpu7vvoWtvzaJNEhrrG+j1FbtJJRtXbg9SDluZusD3zOXSDSrw2q3u3LsrBDl+JGRoDsSNhdAfyZnevXa1nc88ISLxtF8NxK5rOX0NrFNsGUPUVWhw3PB4fvNa7Lx8xuyenT+Elar0FwTRZ4BGsS64UyK6whOkM7ckiqKz5xoU5C/v90g7gEb/nHkTGVSbYJ3Lb5VuF9rIFcmMDstuQyLhtLSZhlHcseQ6ehCi3zW0r0V5/2vdTo54pC2cCaUH6NFeAVsGSenvFLZ8NSzdTvA6M3pjUVMe8vUUm0j0ZhWvGjO6F8dJKMEY4BUW3zjWf8zIh5gQQrbQRMt85bczqvxAHw/pttTTaYXDoUC4d/GLegdcFZIq9W8j+YlJczRVP8AYU3AwJG8AXWFv1A6lsrx1asZXfNAWMDRgDKnEwKV32+v1JTefm/yoOzbRJZEVl9kgM4Oc5Pc5lNxVgdCuWR1QhmvB0ZWLf0FE85/OSqTnkciZymDpYXTv34ID0LfIwOhpT/YHJ6fZ7P0LZU9jlgJvUI5tZc1fmOS1VujhMyO8GawJv+ANi0Mh+X4eECSXg74Rd1GY38tEuJVMK8ame+sCOT80N+/x0xrw0vl1vMhdIO4dZsaQsVmUlcCr9UUHe72JYCUokYffuwYRwRVBqVzBmba94NMNwLDw9Tb3Yhs3wAtF/49Sqc1wsCzm421wGKOJSHFt2tRWwWx98t77WqVcCGLn7suhC3YykqIDHLHt4J1gZNbmAy4JbM5A/Smj+xFy0cfeYYUcqOzEmtHP5+uotreMu2pwZQYMuBa/p1vn00bxejuaa61xMJ5mmC/ZCQrszyB71p5T1cSS4GQ7f1ujre/yHCupy2v146nDZmJWBI12pxY6l4p8LQVzCZfKiGZHlCjq7aZEG3glqpEEehyZhyk8nT9WO7RsG9nEOXenq69NWPg50gjB1QaB7PObRRlod5Bpd9jtjI53H9s8qjhAy/yo0fWZEmUiImPVe4Yp17wK3XnvSifT/gSSMqcdGtOyGMbKaI04XjI1P3VU5pWbojAV5y3nUkQoq6EEXzmp7spWYYd5qsp0cIRpi4D77EtUb703s2dh8636piNlb53FgBIbFdVykXNA4M7OlAgdednBVFg6qh/kznOSR51aelNom6UutRCL8UMz11WLSUWhjtlxlGRoK9ds+TATTM0saTjNU9rCywqBK/ZcHG8bdJpPGaAv3c/Wn7du5+7jzVT7syq0q6uoS1LFZ4O61JD1If1kh/nzGpqn+UXVbVENVLQYe0do1vAaPZneYkl1QnL2i7XyzFLVAHYrv/JDAPQKbtjmgltoJww9AmoHwcxg4SgGzbZ6Q/fnTwvuPk3pwhLsdoa/HCFmC0BSh+nf8wy9ziPboEdbj7Be5PnSHANMhtb4wEJmQQL5A7pM8mgRx64N3DsJQeqDUfSk8LbdV8tC/fiGLWVrVC7Q/AJvZHhJvb4vQkqr3yTV9HxU5+zIdkzyoBlsdgQK5Hveytbal9+zUK7iS1KP3x0bHrSh8yMqXv4mIlECN+Hce+QhdZ4BT52Q/je0dw46TBkwdSfzKz4ASrkYE7Z/atyEa2i9WyRdJb9vYZoTtwplFqB5lgdjK8FadNrK07qcZwvdR8c2p3X2DZ1/EtmHA7j/xtWvFdsAs6/MoY6ex9FlWxSagEc5Y5FbmZCR2nhFkceCl57KqYqz/pChwia7ujc9XPecAfzc7p/gaZKxfeWLObgWtrIOT+fw80JWi5CTWufO8JAJYM2oktD3uwF7DpyCBNSMDwbB7gVQJNjlrPVt0Cri/THWYIGhs1SPHchHd8HrEf3H73aaUDIRyDjr5o4/UszVmjiQfaNN/+ZdmQ1lrUzXy3ehrgGO2bZaWeL4Q82hxvjtEDVb/g4v7Gt/0RVzindSQSECMR1XJJildWUyJ21YiRw/7AWFp92xLu8gfn4nYAQEsp7LbUxm+uG363+cWw9urum4C1VXyCMWUE9hKXO87+BzYEgImyruXhb0W+hmbb/v9ZlYgQr91w6SfMuRh7w8gt/TUSDIY+8ETN7D84zClnGHhHnqvRsyJhWOloeGFqGB+yH76tirRmQ7flVKazwGlsmcYTRk2EtIlxA4MBx52rFC3IPqkYhNe2tkBuVfXNYTEMIq/TedUk/PRSiqfuOWA3vrWWDykShilVsW3karVXaH1WV8+e6saQwf8IJrqZ01c+A7vUSIDf961QQIQpKX1GI8OuvkMyI+S2E7dFWqIYUIRL6h5cMKD/bKHHiaLFPUtKu9Dj5ffWOp84cAiX+G0gyoubmIHzZLOOY+dXMFVIGvovTBSikEMxCJXYCfjTeHFyBrAlF5/VA6uIpKutHiYJ0jDOXB0wNByssE6bYevT7BJdqrFwBWA/N5WKPeVNiuvtq7sLmNCg8iAzjkWeI6GHNgpgK68bn7ydEkwjSe4JJBt0bDg6I94qDuCnObel2wPmYBByDcg6gWaXHpRyUDscn+iWQQoife9NkpvmHkn0TgmPQ+UdUtOrzPLy02dM8T0FhuOZBT0oLFNLS1D5bRYbQ1XGY9WCDr5nE4kXCWqEYgtklCkCfBw9ulK5i7g8WSeTqIXG/Wk9G6ZbEkFuVqb1Zyos9yo3IufTqDoX2M+5iihHrMaiaZBubJPYHuaN60XwL1qEthIk9n9KoyP5M1ksebNvwwdvwzyTaovgHI76iJK68JchPk00xkxc8CVPMEzK8ZnlONBRiICwL0opqBlTBwhZ29QXMgM58y6uQbJz8sD4DLUHpXSAme54bpCXBJiTfWlok+4OEz2SZwCBr/7BFSzzSzW58nA0MEL0mVqBM0E5VQLID1hPfNPtPHJJ3DA7tReXXXYjvOnGfLCoQYi6zZ7NcRMLwsb+dg8simuCcdv6yAsRFd/hvemf+cx7LHHHNLRr1zKesWiAOBlEB8HmulXY4D2V9pFUX+cJplMvhpEnFH1GnmFvXdZGcWC16ti675OAUxW07FprPBf32lpMzZ4kkBsxE1SWSCB1UAIOLH45S9fMREv31cEGe+CdN/l4GL1GQL6l4WoU7hi77XG/eCtGXVOGZ5Bp4OsvjLNsvdPGB4I8+kal7Zk/IKRNoaVNpshAo8sT5PviPJsb/JfDerTvL7JxmkPkfr5lGu/y9L0+LcUFlAn1aAVFjRt/AOMIp0SHSxlRtOH829loC0opuw++KEmK13aS54KmMjuW/RCMnI0tuK/UgxGBErygKOU6U2ZXDEx7y+pkwZ8H01vFzhWn71ENU+HzWx6NrRiUVd5hb/ColtGGE+FwKuPn1R9rWauXrllK5ri1izEu5GKufHrch3MuiGAatFxa/1YSjssg5hNiqjixlKGoAFs4HTXoLL506eRq/TNO9rrd0Ak9PA1MV9ICAtGX/1oi6YuMIQkj9e071HBZXEebHHdefNpxrNV0XCjWJxxeff69o0C8rI8LY6ZwbFQaWZvoPxjTPEesfe491M2VFF055L5YZ/rpuzd2gTnuDc8OdDslLmgRaekapYlnOEdTOWqR8vVwXrNeTX5/hAYD0Rn5Lu3Ye/XVBEhaZh0kkCD3XHqjPUIrtS+OjvIpK2a+Q4OlXm/7G+XCse5rpf9PrBnxSBzkwrzJbDy3i/1IE7RLI2NeAlGzKQjmqeBka3B9LAIS2LtV0SZqFZw22hAPKXJtMB87Ne8HSsgGmAvvw5SmzPI704d1WPcW8YdKfD7iW4pEVmHvXbyjYq1onDXSmsOPdzY8wKPZ69uzkbuR0x7ebWSFrq4E6Ydze1vsyLJ/2qPQgSHnV8QTQwKVJK2uLP6oR+3KOeAFW05eLjR8ZWKJzVG8srexKUOe+zmUCuW4cOvRxtxX2p8d5w80CfWspccmX3rFWRMdwTSA2iXqql3O7QuxGJeUCp37Dhu3f21/aqAVHxwG6rw2yTRkoXg7gCF0kIbtZ/evvBFwFEhgvb2Iz5JYwlMdINr4UCFKcMrpqsr7joexE+SR8N9k+ywZ4oH+Dvsf2J4e18rcsMgq8NHry1uWrJdDXh1RKKHJQY7RG6LYyz7BXxmMo29t5m5gr9SPrmHlfC3n9cYjid6BaRq3WBgGIis8JNLFOnMGiAf7JwrLRsR7xnisQeU+Fa2VK2HXDJ0lk8JMCaKPOE5TTqkBnDiN9V8hgjzwFijN4/QO7dUZ6V/JDvAdfsSMczZ3+mdIz44E2TKC0lTcSYJYM4uLpE4SUqxCWnxHT7cxtYj6jbBVZk+ST1qbaF6YyOFbsuf7shb8k46EVeJbwrrQH4k6y+TILFjlvH1TF0NiSM//TEUc2Gpup65hLaISiy0gDXLonzHLZ6MnzPep7uRIAx1SLpooLChI4oQxq0ctPSrwMG5Qb0YBWXK4WsucVhjG65mkf+09lb58363tD78q6878KkS+rqHRic2DdDOFN1GEbOo8WST8aYNdZadhrc5kS9qPwPiYzarJeZdrqlzlEyLOuuZTx+Dq9+dY/EDN/gmf7jSUj3oMfy1BJQLTq/rG05J/m1OrTDw2T7hLileLtARO/xaNN1geo3j0oGcEHY6j8nvp2Xwf8dz+qRGIQcI6Zua4A0jg+rnsbCIX60BL/aNyXtKKoMIzowU4Yrs4eXSeWuaJ14yqK3QK/xzt5akYUffk3vMF3XgSmxG/gtERM9aRxKNS66RnSI3fnaaMPVhGBucK6u4kLom9yvNxMQRIw/HTawVkw44qLhQ942h5/xTVAL4uuJvExf8WE6Pygvwq8XUURzmhJvPf40+/cbN8mgcc8hRt/yISymrHeyl1WMl3B3qvRlt0oGo/kotTsiT+DhoGmEVvUAo5jxhlHfaabvSsEiVBCRqUE7MyA6L7wE4xgOHZ4Zu7o3Bwsub04PWTS42cRpdxwUnYgy+z4CNwdeF6jTrjF1znB/3ER+uOwwMrBG+UQzCohRl7l6fqT2O5fFPWMxUw5xK6HOHq0GEsn9sAEkRsVJUYtYa28Ua3r8XtpNpWzm69df5hGoQfyAvBjyTV9AO3tuCJbU3qcb0/+Skvm7ioE6NHUNcXwHfTTbSBVdp+3DiucsTNzplRrK6XpfHC8Biu4tZ+wGHwNewRqLNFBTdttl/KVJhIEIxBapX1NqN1N24uolmGbeH7OK8Jp2/69eCX2m4hUzfS+tmfraQ1wdBJJo7UKOSZbCAHpoPvy5cOhkUJPS5+mLW0q6RRMtjFDPlO8rKEDjpQKQnKdCwJEUbKmjqU/i6O3B9x6FQ2cAv0F+pFt7htXWH1pUa5+WsIlG6+cL4+IIo8I4U07R6KnVj8ryPTz3I2RtjptNNK64nPuLPGcfzFSZsPq2DwgGC5ICISWziW3JYGaUKHruzWElZv1+7FmV9st7KGg9MFdzatEKcgIBltppzxFqQZcucJ0also65emj6yuTArYCeCB0ApkywGb8nUvCE5AcHGUefoHS3ppMfuGaxHz9T4eaeiLUqVF7JgAFINRjdISmYYgCIE3xc5X+r7R7i+l68KgZnvMXcxlgDNYgOQA0Pq2z0NOU5diVQRWtkQmEv9ePn/B8VzIL7pgPJknBY1U2l5cmTyF44rcmTSWKTcT4lTskgwnZy4U0QPJfGv9uDHsuUjpup3IQwBVxD1cznqbt5hDmy41rwYtmjrcLMppHX+/VfZIPlrcy8lAYimxG3N7Btp+Art5ZHJY5+rfIfdnj9IOsADiImGnwT/GAJClXBN0wC6fucbyP7pPRsQpZYavyJv98aOD55DIjIvRmYUuOLHyCeO21RK8PxqPybXIgsj2WwGS85JOezSZUBQTaT/QMw0yhS25om2dpKQoBtL+z2bPuusLp2hU5gx6eHT7H9sRcXA+Of99G43lzXftsNpyYXq3saQqZL6uKjvJ8IZt3UJWPyGvWXG7IbFmAUJid8W9GDA6RLj6QYGvjzwdwJLJ7mFl8XcQwOH1i4qIHLvE+1XJT4A/wN+PeDoTm32lVa4wOZ4uk/a8G9ul5lJGzRyPBBqZh6fg8668urzW4FzChHQaiKgZQhdcoDWVRvREjGTOpjgeCe3VW11V3HGDx7assgKNjjZE0Nu6RJkdK75bgQJEvN55dehlzoaC0RFxcGLPsJNGEnFpQQo9qTNKdBb6EZLqf685walS3jOb/5MKTCbxdWQCwBa3FTCCamzM+f7ECXEySXR+fD+KpZ5/l077NNDUwwcOx6ywRdBAl3gTH5CTyt4axlE+o8eMozrySYq6uuT90SIwSppbrsizCnyWfBI+99paS4xHnDIuEGYGPqO6b1EiT/1+zHLPZ2VKGAlTXWP9eE019jsinetduunq7Em/zXc1Uv5i4s5keTbd4DiETMnCFJrMK7AD6FrGf8LVkifNIAOhW5UM30uN5pMWq+j06FLyVfVBrFO6fWcDdzaIHX2eU6gBX4V7YmskR+sXq+y5fgo66m/fZPZHAlNQvk4Ys5pnxpKlQq8Ulmp9HMyvwGeWDM40+hq0Av2nX12EFAD8tlI0OA0v7YiRFzGr4eKhjIQULytAz6uUo1sa5WyAIxRr5k4BXv5vQpy2EKPQWs+6BysUwAzURavOO6NyCluFeXHm3yJJsGoC4TYdT/bJ9hxiYrnc/E0wEsylYVKX+CMyd9V631NSDFXyJyiO5kFDhH+V97yAGxsd5e63Fu5ib0syekR7VHFMVcsU62LOwfDjHyaUgx4r8O9uX9qW1gxbsTyYSMw7nYngxJZWVJV2h/ikeJBN0yfOSLCh79Jxzzkw59P+8AkK/4ScLyUOdC/snIokJyOtpv1rAdnPUPSzxkD/ueJQLGzkaIv5JBzj7hlTegOFDu7mrThf5YT6QPp1rE3nngx2y6x1owPJhHr24Ievhl6D1xsl695NW8SMbtSvEYeAJ6piB7NqKjkgXKNJ1off3yRuCNKdIUXHFt6ovcDYrIMHpJXrMzpsITZ8j+L0ddYqXk8/lY1AWOXwYCCyDGlZFVPiFQfhiHLX7uiQkjXMHdx+z/LiOGLl2zbfTcEY4rbM5n4Wzn7S5NXp+IyoAWo6cqmLYD5K9moJXGO5qKFr0wQ5jtnIHm2Wmc6W3Bq5JzwU1lNpxJozAuHEVqttvMh13UdMjG0siapabef9IyJVWqz8MAM4mfD4fqAcV8cpK9VV3Le/me006aRtHX7wH6aLaYQAI0JZDv3nUKObpFR4g3+iz1sxc3mYgO8bn1DIzqKS1dfejVceZGjBZfZgfx0MKFS8Z4ghUav0sHrKmJ7RN8NL+OBGXwweCCexSlJqJ4W6Arv5xxjcriCakGkYQgdyzU+uhmyf9fSPduf7wRKD9LGORuTfYk6AQ1+F+s2MxiI1WoC8+lD0yFnamusVZk3YjoID7jebdHa6f8mFqxokHbm/zMf1IhENajg750Cvx4BByMGNIC1TDuyUUKv+1lPDcwBehfuMXP0f5YgcLan6JuqIy0ZlZSY9F32v2tIij5bucJ3J7gJ95ELVC+8knkxRunBEHe0ZxCDcnrzYL8Xlw27/z6VJV5jvMFHTy4KsoY1gCpW3B//aVcpIzXl5635UvThUDxDXVmyd5HoMpvC3zY/tVYThbOHeb5kIa3ddh70YI1Ee/UmuK/IrPSsdRVqI+zgfjQzbBSVmfjqL5k9Jr/j/00BEpvTOP9stCLmDX/OqYnLxdwvAkXbv0IAXuQxwCoJ6jBswyP0KfrpUSOPUJssbAbIntGlpPGvMwSEjVxafIFUkmpJzzA1plcyipLLatMgG761iBmhbtcw3YqbudgcTsrtv6wOr5v0FvL7MLPomsFiXeo+ka1vp9mqBQ9nLXCu1sRqEaw2BeLT/hpV3SRm1VvBQ40WROSwWcleKWiK/c8PZnx1nL7ONNlMSZZ5piu1tIkcElhyCLJG/xY8371ECwjG0fA00Ogd32kFjTNvUCpJr4vMFrUnf3zHDnRXMp2ngMNvNOLQ3wMZCHBzrW/aggsLSsK4VVe9jhMbhD1iAQAbr5e0CME5CWIq/FonGZZKzoniVQaFFD5JyXEnTC1zMs0Ad+IvbQHSraDlye131iN+gSIJzlEeO8PH3GqzW5Aq2SaY2lFxFXgRzpqKzKONa5X8fOI4qJeBZpyAyoeRKYzaNKQR75hpSargEz3oE4YbMqevaLgWHLVkMFXUIq8KtynG+eZlbDArzOzI/w9D65Hd3wNjfQBalF66kQD1/fwIX0fTWyqhEJxOGHfoPWIgSt5sd2LEmZZr+p5gvZm3SNu4wVjBPyt9jw2qiqopDO9Iy5HqQ1E5dro8ocHoWN5zsAUp092WUetGgxz8xGLXNjvVIKpHK4x+tM6rs5k2ozSNhMra/xAv9agQZZ4m7Tc30LmqkpVY5md8mbtRzt1Sk7i61wYWgbz1Hrr4fOq8uA+/GbOAOqdButdTKXPs1CLx1syDwOp/nEcq0yGd25T2zIG6Smp0t+/prITZ+o8iQulYWrkKFy86O0dQKV4PZtnzF9HP4WgS5vFjX2AqhKI/a9HeAQ94dbOAyCOXOBPX8dKDI/Csq2e1RKfBSREbXW1dpTwK6tOJilc9mWwPYCNxWfx+DXyscpOLNlEXJ05HLrbIRkPYRWUPTGm9GEyfUtJLVu4Y5QX41kyLFSk7o9vdSHZjV0GL1/9d/0yaRwSpLiAokQVtWcVLq6OmwofX08jtX+eeHYmMNZL1SooPQ66CCrCTozoLLRvBIAlD5hQGjbmeptFb6f8Oq+9qWCChtubGNPFjMFbfpEFRZPwwE6F2dnKyxBHDRdN/UKX2cN8V8GpUXBqbr2CVPvwYD185yeNxRCe3p818LbxObq92h/EMQGYm3OJfPT/a7jZI9JJdahi9rhL0wZdxtKKCGkts/cUOhfy3+mlwiE7wO0ai5yfRF8KMmvK8e8plgpl4WY5WoPC1UlOigpdGUfQ2rDr3+Ix9KThW5sIzqoEphmDI5MF/efipJQETio0KpWcJKz/L2xn6XKEpRj88djK+P+fdmaYt4cs0YzKIreymfE+KTGsqUxNrCi0tNZuUgTlD8KKX3+7b2T0Poxtl+UhVE/2UnpIxEdsDulZ8CjHCSbLHFkqQbTDI8AV+11B5X4RreA7uAMXqKbPTmP2ldx9Ez9KvKI4nBsnuTmjdeiKEF2YI8yM+dZym3dio1ond5/6n0IPPnfhROeMIfpVNBCR+NDc+n2zbgK4gqEV1EOf0N3aK5V+oQ95Pww58nO/U2J51cSCYo1hSvXYlmw7zv7gYFa0jeM4lOie8pJtY8XcsHBXRi2ERwDJnE7LdxEa5L9b0rvZEIh9vXmUv1tnWkS5ZpnaEO1Cfke6r/G3KcYZHAGrrNieVpbOVUGdjcwwnGkwHxEGlGbbGDYbVrfHd6rcDX5iENk6yY5XNa5RwE2QMFA9WX0MHSdtv55oLbWmtt3R1knwkU0HS+nPPMyDgccpDYwe5eUjPpWjMsuCzfpGMu+yo5wDf8N8/2sf1ev3/Ve31+rpbvn+sR+r2Fp8n1cb5/QTn5NsXw+/mvk7Tfn3Rwz5Ptf3z/ZA/1e2TfN6jJ8n1sv1ezDPk+tXfP6XM/JuD8np918nfL8/SDgb5PqV/n+mH/n+rl+fu/fJ9Gz8/03L5Po93ydrNfB0d+TuBvydb/xNlAIxSgfLUTibmp2fr9UHAPmOrvXYBdA8YNCZjUaaDv7/So1jRqtrAmBj+XsB2nDSgDWbylpBoo1ojMDMBgo3j5QQhhDr2ppzWPLweQ5HFwtYYwPqiHxwz1qCbA1pu8C10p2xqS9VhjPqcCOJdNmJ1NsF/Rh87u0XSsPcnDUDg58Tz8OgGoB02Pt2SNwi/hapmuPPunt+VitjZAxyU8rO5WCalSoUbmsbDDc7esJXh2ECy1tVdFb5DegGF+DsdYjSHXhOygEnGsa3ehDhrn5UhfJi/kk/+++gizrvVT2bAYix/B78YJutmrB+Nt10kA5vT4xNcgAeV7+ZLFUQHdmd/e/3aC7AP64AcoXkxzGXgOPzDbC5wz2pwhd4adk7QLxGhMCP7w02+b7dIF3jNg71yO4ufgbAmdSQXizm/1lG1kqc6/MJXoDV2zmWTlR4MSXxuao7MYpcLBVLFyn6eX3Mdte8gOoRsF7C08PvxaRqTNfjhrfVNiv0zij/DF9fH7IgL1K/KYRyWK9A8b0uvuGACv3VZapQkeM2xXWNjFfhKCvFwHH7j05E7ThQ6grzPHkIdZGOKUILywgSOxCXiDPAE+GreoBXhubOOQyf2ufW0EJ/odocpZnVQdSSMHI8fKNJfAr5Y/Jko5GCXgA69LUU6Z1An/sAKBKd6XHa6e4BNm64aXk3Di/4Sxd5TxNpDyk0Lj/SEiyp620w0fjNfXuXnSGtmH2p32UdsWETrTtnBxJsXI1KYwZZcnmdLDDJTDVegWcJlhy2tp2nSgPWgVkwGHPU1I+oXGJ+4iDly65cXBFTLq4+wB+qRutRwBtbrDfFUJGlczrIf8D57akA0TqzjJ4sEXalFK6FxTMWGVDlHw3T3rjuDtvsm1QXf5iflZ+p/V28+x7wYT5AOPmLMRSVbOozfgDKjs1qG5j7NC9QJ9SFzQxJNQipem0uMXwJVaoGbkwNPOTevfeI94HKZ90IkOzRvDjvBwFWp6HimpZG3mhx74eKNgImDMkgbUNpX/lqFliXs+9+oUt433xlPgutUQn2kYsTyuo9x/BcAlki8kOWINrZs220MupKLVQ4Uw+Fv2c3tVkFzAxiJXW/vWl7yTXjAuC+z9tXRuI5tH0fMKU8bVeWSXurNSB70Tky4r7mmUaLmU2oB4iByf8k8fjGqnh1y/3atD63wAwcxqfEDR6KKU6cF97L3X7TJpQntkIsZdEOyitIvX+az0G1peNRWP9Tw7KYeyO/Weu8wHLhXHcxsbj96JQLjzt+uiTPt+zoC/snfFhD44bsGvZB1aKjLBIqoG5C6ih5sKSmAmn8+o8pk72l2wlunfgEWJZZymtilcbRYz5QRFd7eXF02nGCxV0XJNTmeQMsdDg+3/HnW/cFam0MXjksTM1is8havTOEPnWpgR/u6UMMigFsKJp3XOImd9psdPqB9hKt5we0i+LZPajAiPhuqPuPOd6Q1WT4svjXHjplXNSqpEU0wlnZYTryp7sQDFnuxtyzxnd4aWn//AY1ptJfwmsf/IhFFFWAS5uJ2fSQvhopd03eoUVqJ0yiGZZU7MgGNwgXkCa+LNkEyBqRFRgRQKZaXIabsT8l4vU23R5vY0nBUx/8NL5g7Kf9a0eMzo9ifW63OsTu7hSGAKzCZhOht8MyeE341sU8mAzJnxX81/3nXL47WqysIevPxKnZm4Z/IJnadEZRKw2LRIq+OWbp5HbrExwanjn10cDVURumspTEXopt1DGlT8/LQnUqCr+o2AM53foirE3cR4HkiRkBSAQsS49BIriVSvJb+RGpG9+S/unEZuCTtTfpktAdFhgzibsQPt8Rf11T9f9FVqS46QEsuz668YSobkj9r4bCW2l5B74jU0KYPhB1zRmH+hmNFGUzzUK64iK80uFczWVzlfZE9wk7ClwtQ4wscJEJQT0JIHlsg0uC7eata5EjxXKuqcHHxYB2u9doZOU9V7ePWOyV1h4VYrQH4EN+AwqkRSIlMD5zo6NVb0kD2e88G4yhc8FIsodb8slZyZ8UFzJpccfCQChqXlRFoZDXpGepQIwjAqUZFnsXwYjx50y3ExCi/PDa+X5kd7892Pn7aefmKsm8pvDZ7YON7Gn5SsC+2yGp0yvQY+6iJIxA0IgkjdIjV/pvjfAt/D+gr44wTJBjzeD5X0b3kZdfSJqFLyUFxJE+6Y5ekMjYUos7g7g32+O7Qhz3pRo/2TVNxHVupHPNnEfDcMDSvvdiqPGe/RnqG3drbvwbddcfWDMNssMRYhwO2chbeR3IQyHS1Y+DqxuQW7ssAvWTRgD99THECvGtEUOYF26e80saqn3OJ14Kzx8csDFNCe5Mq8QPWQ4+ZPH61fC5d6qvh5AcOAbk19PRrbiojmYhum8hn4TtALEsvOMIbl0xXz+i1SoJaxC09juQGLE668e9btj+ohnoL/1iZh0X7z+STZpfElXcZv4jWCwUuK2FjES2HOP8HfGjhjrqEMyl1h5/FNBBMG6f1dXc7f6ckGCFH5P9edBNqgwc+XjsUuJZQjsV4pT0qXXVmGHYt8H+xnjAU6X21HEOy0MPRBVk9nbN1nN0Rsdqj3fbZg37PBrQiC071Lcwn9C26MWq8IUZ41We1ToIt7wbFeL2H1SMFNNtrfrsnid2mWwme1A3NS0m0tkj9zrEmihFfXDXJMBuXWMWCfe+E6qUCTibxFH10y7uR5k7AoEJxeO9vy/9PZSKC7AgTsrM+432KpXPb8Y0rwjGQWiETPABmu7auyhFCwGdEjDrcb9nQxtsi272ReE3xK6l2+qDXCqcsx5wkhuWQD1OGNH8rcpcXilI2S4DTNB0G8tX7OtQGvLAvlwpWrk/Hp3cNIQf/XNSKsiY+/wQ509ntdMFsWV72MgH1IGP/VkKqyvcz7aqQWEF0WAPNUjHrFjnzfwQiuDeidI9Hy4Jmf0Hvy0nH4bP24jnTDE9Jmc3bjt4an6DSYkWgoYT6nWkJAUwyt1OKdAkkkOWNfadhzU+Y5e7t+u+HnAtF1WH5/BteC/eJDKKc+XZcRAXepe+BW0VJO23kCyfdf13iQ5ddGmcJOaqu3HhKqqxr7GpcN2fFxMaN9c0oZAX7ewiZ/zJDL9kAYziP3mk5ywwOZ42gxI2PLEEqPNZTPaxb61O7BI+bP7ZTDx7Yg9b8qCsDdtHhGi8l3d/p2MVnBjSRH9kB/d4BcGMbWImXRHg9XmC4sJCjc2YA0jWLn+4bgnwGsRNVvCiwxYi5QDu2r+Jd0x6DwCbSRuKrrsi57JRb/y3bzdWmx2zg94/NdAR6zvnhaj5Y9Z+zrUE44D5mR2rhWNq+92aFUGQQyty6fo7sJ5bS4fduIcPKZ3hloJjxxEji63BifevlzIhDiiBuSw8il1FCQbHeEbb84LlgDY7g5Lj6QW9JvxeDMch7/Wecw4Z/Vwd776pLbVnycnw5EmA6403y+cGxwlk5UPdffO4U7Fqy+SZn9gx05BGpXt4u+Kf1wdke6yhKpCCiVUKw2w60q1dX8QksoZp15oRcCEITS28CSm10d3dpybdEjTz1gg+keQ04Uphzvgye/CNIl47RVr1HwXLgK8vmmPQppLr+HPTRuWSS4RgCHDPpY4YvTAouKQfnFITpBG+y6/vae7HhE9232U1g+24cg4nAn+S9YIYv6zUC8IYg9eytuXCDkyhDRXX/aWQZsE/2iFTBoR7bwCG6psFDc0Ch+50TY5vJcV+ogWJVfJw99o4TXXuts9LJRfEn41H4nX/Oc7bbLoSOjzXUCdyRJku3AyQdinSc0L+w1fP+Vqo+W47Fw/WNvDAOR6tcvDg8wGFDRRjF+Ar5MXbrv7/7EqBji1F/oqOi9rpYfqvtxBy6QavshjXUoHsE75BOfz/vTDgM8WyEBFFDeKVgIJUpDvwwutExZWJElNfy7alnl4kNf12fVFnp4EFgdvvXPZLg7qmTqvQyB/Lrp01kQ5iTIf8BUZZMV+xlFE5W5gBgn8hnl2tIZgV8aa14Jjr8AaD5yTdLEwavYu4m355b8LlUzkCW6ANvSjk12ioJTRy7KwmwBhwqB3EOBYWQelKW0tSyw/ntU6hqW76Lqtwa3Qn76xe7TJm95Hl9WLBTMOr8XnZeMZjhXmxxH58Mxuax03IdgymkeDX9nuNDy4DoCz9glFDNr+aVxGcZ54NwsZbZgnXbo7xKI3hFhVksicMrMpLwOfmC02UORMWZZirZbLUQEM1YvqVr1X7HPmw/qtpOvq5sq56DSE+JjGPe4yKbf9kRDBWgMuGI9XIvdetq10Kik8broBsFY/vAnM6NDa44ZB3wbuLgpCBF3Lz9QHaXYV/Qt6cEjPw0D6z7NrG5zjM3my+maVV2Vi7BnMe4AdA9/rFYRrrjDs1Di3xdbnPhRBns41W3J5en6Z4v5KbUOPb/RfKNbTpjADRFMlZ10s6RmlLLNe7OJm75AZ1oWcHd1r3hITmaOtprjbAlUkdoPtyQkUG6MZYOJ3gq2bFVMwXC3a7vqxskAhnKDDG0CeZz0bkl+mGtLxWQAoe6h2mJxNgnJMv3k7S4oaC38nFkFSPfMA7J4g+sCgS2diqQIcO5AUbQ7OXlsCy14WlPJfeu7bIgModIbkdxRgD3z6nx2qJ9R2iYkSMM13EQnCtogYQW0YnB/Kx6xkW0qPB1Mgnqivt9kO823ADQIaMyRW3akwbvCM2CceCEAuBWDOueBjV8hLRKOOn7ppc7gPO08YreSaR+Dh7DV8eqhu8lfo3Uk9ImEQL5nkqXRcq0TevsGJE6k9FlCh4hV83NRbZ15tAl/HUI9JtmmBuK09gIy4qFAs9CuCMLRld/3r0gN+k1idDZG3/nK7wTzoE+3nv9XJgoZVSRyYm+n/s4ODI4RpGYqTO8PF4A9awT9q18Q7uqJJ86rw05vjit52NS4rgflHDB66mfvysVQZRKha7G5+Ql7LIFmkqqPBpUFOXh76LG43IPDvS8ID/2V1cDVACeIEiZZb/BDIq84CW725ky7+cmr/ldQ+pnNAu97dwmtqqhwNbHwH8PdHS2vfCvao8fOVKYKjBN6J8f0THoGoMGejDXChOKcvduLXPfZOUOUgDS91DQQsZVXBL9CtqId/9m+kFumTC/2wRQGWLciuNwye1fiYBno7GhkZ3uoajMjNBTUUiESJoYaJbcJMwDsWiDpe7eOx2m7AinScsuchDkvBJt38+LvGXEbg5TsCqtDUZM98DYILE/ex1HTq0aix+ES90P24TJBiq7zIxBrWbkhXShIgywuOt+85gDeyw2MBnY2QraX5zrf99u1K0ynxxv2lnzx/v84htQ6zNHGse/YKCLMWU43qBLDffSsXJo8mM96oPQjyIYPrJdaoUeRC4R21/FNd5QgLj6bxM5QfNpYrcPbRjMP7I1oA5ogQlB2KITgHJoNqOio5BNWqV4q1HS3/gs2Qc0XywIefPqQrFQ6869nBSBnrFBemkum3xDU3s7QXoTE43Prv0hIHNK3abAHJfp3kuegRhDP0quQ8vftG2OEw9utDYC852Pd/Cy4ODQUh8Ippmg0u/TEwtWaVC+74ELSOcKFGArj5bMCMDLSPjpXVNXVfWYScc3DclKxhE3Xno8Q2ucG3scZiqCql1FZ0gLeEZn5k4JcCpYVUBDkrv7Zbco44TiRdOdGsP9QYSVNqQ31Pth8ONpsoNZ6lh9ujquvfRXnlCoXPSeWXXOPu/6qqBgzqrhsEQpi4p9xASGOmMTUlClXdstfUqqXRt4eslAqlmImosB74D1W9PhzCjl+rK3TZJmvPO6ePDO1XuR99WqoEgD8qIbAdjgSgG8pC8XonZmWfVoJ7ZdHFRPJvOAwHpKKxfw4Ngcwxq2f6TvylrW7jSTlZooIOs8yqwR8TIWO4eea6LrNwkQLvi0xTLDZGkn6rl6G/E67pGBpHI388+CpJvfqIaNfolYoRU2Es6XbyaU3qS9m8Wfwd/R4gx4w3zkslrJx+cS4fBwzku36dQzIPmI9o/abfajSJihw7osk9BgaLIvIZrWwZJ20fXlj09SiCXWjNyX3btgaX39BlmGDeY1kK1chCPNmSHN8qzHzoUva6rso4pt2Ow3257TSqg291RUH3E0k1/LxVBDJxkRIBTI6AIpW9FyFZ8zymPYj3YgYhFGQxLVE4yHvi2iKnCW85V0gnbjC3+FD1yDBJxqPeXJTzOkFr2MW/LZOin7nywMrAHfiZFlec6WxC+GF5xw5KYByGg1Yk+7UD5XTZvdgW0gtvRdy9pYLA7g+TF5fmnkiuQWGU0Z2IGBhkvr769j8/wqIqcnrzP/KtnLOsgdtIFX+AiI7EJGo8viOJFRFtwB21BWMbaH74mT8lKCeJpVNz7FKKeqsq4tyaI84hFW3II1B9VeRpIkch3TAAoYDkvSWI244chPTL6XvG+ZdmAc49d6/nWktbz/QXTXDHbOxXYH2H0Cknu9HmUUMWwJNQhHlDJnFSnpoL8X4/5ffeY0pOAHmpZJiVLe4YADCDr0uMyHFifgo7v+vXyOwFOk3P3nkx32wdFo5OdHR3zCYk32x7MSRQgeL9SZ2NEKsl3KL6XisCBhcWWCIl8BuI1agaeEfF9412qEPrss4nbab313sm1+xDnLlgdlGQ8L+cNRod2Psqm3IFssAa4shwWHwM1TCVdRH06aMJ3ZGkD0wsRpiZ04IeixlFfHYD85r2BQqG1H7BYMyWDOJ2if3blWf8FoCQ57rqDYSDJjPaeWB/adtv20oNXK26G7abEcLGYc7sBNsNC0KzGbsMPs6brrAdwFQW37TS8S6koQE67xLg+kwGEI3UVC9oSjJEdwqcmkyeav1QTrJkYd7Fnv79OFx3LpQEeAavUfZhB1Vn99wq/btN1aVXBh8LKJMawu+ICJK3D3WWGCBkmUTTG2sK2UOsr7Zl9Lh6MUIlkZ7Ps09LLMXRYfMUtTbQecSzEOBSLk1Tt6rxeHEnG9pAh+76QT6qWjbf26VtmZ35xtmwjtMfTfojDr25qJvaG/tYDzjXHleIOXOnPIe7Q4hjwP4mVHZt7f9H6X5WdpfULRfLsZMHOfS/I0LlQV9HQr2GcnTVADmxZhpgSr9w/mUzvWcCn5tlsWgI5SWAcd/XcPMgGTpwn+2N91hpKnTcWLdoLK7p2ULthNe1Ba/VGcIf2fmlKhSvs+FGzcXtXhYfOGI+tA2PYNAQpAUfHGgLwpM9Pkae0Z7KCVhneFKWz7+5spbAIZYdRngDvHFIOqOessEuAA3e7otoPiho67iuCk+aW51KI2UdkJ6LlhEZJ0M5qgIXw1Ys7Vp86GldJmhiM20Vsl8sgStfMdCl1xg1ykEGEEqD2KgJpa8pJSpPsX3ke8mLBEwhgRO8uTz43Q7FvEyPbRWA+MiDlSCn8jqmgPNYGobSQNUk5ndH9Gku2pUmanwoGUdOSrhnX2Z4u+zvrsO8DbG3a8n8IF4I3FE2X03SG415wrQfzXCMt9MbMfRMHBgK7wQjTz+zB5Y3wWWlHJrlNMxDDYBzWI7Dq/V3XA3Zn1QaFs6VN/Y8+c+Nc1dLCPip72r+SlhB489EIEj1ToSahJHbx6eOonZEu0crYrzVQxR+U4419eqf1rfrcqOzMv2wImDZj5jqPGF8MO1MjyJLZfhX9i66/KFGpmMRmAdIbm0DpI3NUShwf6zwM6sQVAPFHz+Jp2bmJ/ygw8gjW8oTusqQc5W5SLqExm8QlMA27rw+39Eb847DFPNa37tzrsDsIXpuGtqAAfhj48PTd+pUYdBl5kxXzJpw76awpOa0/gzoii4CY7QOf7sgj9uMj7qK2lGkTX1b2Z9Z5xhjuehYeuUsVBzxwUJYhPplfaRP9d8A73PD9q0Imw0f9sxz9NrbQHnyVv75HdaFIHw+GxgbugG9JvWQV7x4rLvhG3V7bhd+IbYqRnL1CXGHtf9wCzEdXRVHe+ndb0Y8xCls9lMSQwzZlpUdXFy/vFAV7fYG2w65+AnYyXzbZssRqb74eOlqaaGiXsco9sX7iajSZCdX79pfBw8AHl/Td7FImu0Hlw3+j5hdUziNNe8T4pTVza0unQ0FlutFkz0NU8zQpdSAJCGTDGnignwNA29LIWq7b/IigovSC8BO0qlcQj25SPhl+ljEsslguFnI13w8VGp1mZE6OgXIFlokMg32t7J8cJcQzBHMTitdXOTcwyXO5IQzwNgoALmsVQM64hPO7woP44m5C2LtAT5Ml9JVfAtQ8AVaJwm7VJiluDnhddammMoiyrGY4bB64ID5JQz5Mazz6ngz1bmW4L+Oc9Vv197ejBsEcqfDx835NdI6BjdmMJ+Uw5DJZ81+ThAD7NygHlLU5WE2znxOpe7mTZaYyQig/vQ63fN+nzUy2WsBCcQ5+1jut8hJucsF6kVkBFkJ5jZ/0y/fY6pZBTbd366sitZHvdput+0lK0Q8NRakswN5fgufD9JN5BWTRaPJCCUjcyO8FvNLmtP02XhV3qaUWvWo1j1vqpZBmmHY2BMEHR0Sawgin32epBimZiyn5izly2AQLSs1TlV/RxTnifOxrUKFqZEF5WYvGr1FXYBoUp6euhIZk92VxMSroBS+gnwfx9hjHWtIqIWI3KnLVEF5Yt7J8fnXq9yNwFjtM+7sEr85+yXN8rYpiHzxaVk45GQlk++sfHXfKsFOAQzeghTB6E3DytvUCsqKLYLkpydnxJjV+HPXOAtsZaSF5BEkqpSRnlqd4cjrnhb7AdKkW+azRpg0qS9xx1uOA/FwmQ6f1uPSGYtvyl9CEbIGpxzxaUvd6907fOAkzMPy79rap2A05ahnC1SaoOaJXf6NoajYlW+z4VPZjpUrJ0F2p9MWn3MSiI/UQnF20I68tEqhcdjP2euvHV5JYslvdHQZkHFDjZZW66i1hPt1/DZn9+GYG1+Dqs49aQHFHgc3QnfZ04wqL92F1l0JJzlUmhlm7so/ZS2D3JbXCkuMuRxFSILO69QEbItE0Psv2qdyuj8cVijeFaISiu+05zmtL20rHU/Lo6nYyhhiba29jxFvuYqgls2EvW9ABAVqIX50jdeFp2TcJejA39S+6Z2C/E6T2isxq3f4mMPUtsIm42YnP8bQJ2QR3YhXOoJ2M2N0yJtgzXrw8K0A6lGWdfP7rxQwH+AIPsPwHjFPRWyxf6fvBs5vv1hVffreMokjIHfdXF/DL1JpsoA4gOr3vOnnY/8kJksfeFngNaLav6hzZOqyXCL1MmadHkIDuOKpyOSzZddfEVSj3GcbchCnUldzO3MjJgUeUsssveK793TrSgKa7vVaE2gCM81FUTd9XoduUV5XAbKQNVFKNkIo9MP7ZDfevvYuEuFxTLMAi7h7msVgcDRUZWt5gIaViXsT6Jg/R/1C4do6RR9x2E2iExPlila+HrAQB+QpdsGTFTyDcXNyM1qSizMimZaIMGv8l0IR2+mQAnnfydXWeFKK4FirgmV5IAOlOW1qz2GvPJ1HHY1/iiZtLxU3CYpzoU/11O00/Zk94B8MoWTfwEVjAWRA6qWP8prbD4+wEkzoUrSEfy+P8/Kgae7/OK/uf9RUeQcxV96ILur+MTqU/om2K4+JqROykCuvoO+Vy6Ft3XzReUwFjkIGJpItIbbSajc+wUfo+IPcZxsAD3/0EziM+b+YlgtC8xGHSSKCHQQErA53TGJB9wrVVPMQnw3ThX7bA4JzPew5Bo0bxHt0+tTWg5BJcxQIQ2aA2VImeuAIelSHYSCFj3NUchBwX/NBOc/Xcl/w8DBttAd+O5McFQ7UBLafqQWc3PzHc5cdeno7sTAab+/uVTfoncPEpbTeGyOZGi7iHll0Q+W+0hcKvdusAl0w31x8CVrDg45mYsG2EUHn/Y5MitYnaYaOBAaJVOPL1CBB4qi1jdzIkWH9DUhJBx/FrxSpIc9QwAJfBOHXjhNwAV+9Xo2b22fexdyJlkGn1/1gYpGJ2ehnFLY34D2MztSMK2rqVvuMT9ev7Ro96oqFgya2Pt+U6v3sInnPIS8tPfRa97cKdkTQiycDH2DAUEg34Q8DYG9kDBpY5blhrdCwLavJexL9ls2mqgNeRXND8qDeXku4ZUzhNKPB0vzJxs4HXFgZjP+EmG/cFRnmx6E811E+sujdCOIqLA4bwBtynMeSOnEdgpILA5BOFK20hdGV+brfCacPpMpyVFrWLY6ZFxc8rHopHOEYACxMcLsx1LNeBSdsO50ViX23rgceYL2j8I7QgkchnlJ93SgWa5/Uo8VN0oI9RxDTveEQ9TD+a7Z59T64Iw5VrAzK5+IubGOzD6nBny75kAe/XW/VuXVSkz4DQymonMYATP/EfmSGtH1GFplOJVH3bDdRBaq39Xfi5VPRqKC5SCVSTsJUvOpAoEc5XPnBzBcYH3QCwWauu8kVGC3eg+4x62URysXJFqQj1/KV6uh1vQbTLKVsWW2BcGVIS5YV8W/txyVNhgWsde3iuiIx0V8UNSw+WIf+faaLepIQBPsBkLjBFi2h5qCjpA4u8lQayCXMrbGgpRA1HNZtEXfOyGGR3tkoaBfYwlC4WmqtBRBIip0SuxSd6GQ2PRl9YpnSTN1SXH4Ua/op4OCu/K+mhDPs3Bw5LCUd/B4UNfyi01PBPD9+eMLB15OYIPQw/clpspdKpGQ5KTdVo72G4ESw0C+eC6QGvUAF+9P+5NiJbrU2Z1+SLIbioeHdMCOFzGwE/WLeQNsMtDNnDHKjplxaYpt7/l23fD32YcGSURpkQ2dadydqvryVJi1aPHmkYheQixnvwTt6DGGQH7zgGV5TjOkFVPS1pO+tAGuEEvZYDDVzI8iHP9N3qVdrzf6fogMXr/PO2Ya2SrS0pUVj2JS+O25/iWCH8epMHpER9Cy/lst3aj8xtQHRsbPdK9NgAnNvMKjw1Q6DnhGPUuRX90n5bVhuH19zQFHhA69vr1CFrb7VBzzud0M1pCDkN58XdJWIHb7m9rEmieT+BUYRq5ggJDw7VVYB5SZN/jMdq0QFskBtgiieSdPlkOsFDt3uHNWsJuskHS9nD1efI5DIgoA2uELfJFki0R/s8TF+MdToyJ5vGECuk76+97o7ad9gcyRX51z0dxEEp38Ec2oEXXa/pCPOCLp4VSVw0uA/Mww7A4f4tiQXDhZL/bfqHV7QOBl+tsWTG8MZ84mIglDh6+i38lpqYc4Wxo6TjvdRygcxaW0NVIs/DsDCRA4Nzu+QUX+x87XTofWfW1Jw2rA78TZhVH1Hy47XC+x9GX+eQNTiEvdKINEHBUOmp1MQXjZ6BGbyIHZV74pYhHasoSpSd67RTvi14pZLcoa++bvZr1ow6pgi2Zc5RlolwE13ItMOYPnvO253ytd+KVn9PCoHwI4Gcxj4rFUEw1VzX3XVBm+oF/+A9g97JvCy9YSWBanxi00qOcylhjCOVr2BSfFfAGWURMpERNAH5eLAs/TdI3vB9gPHbClqGNayfV5MTj2XvENJo67eRwpEFubYPyOu6C0KSh/jauwHBdbH7k/C1ah889hGIry/n4EFGMep9ff3FgYWihPQoZEuR4Nyy9/rs/HL6/1xSI9JYtWt6vM7sHWlM7lla4SO2H7qjI4AfGE/sN56k4/Kfi+YSWmzoPDkCHng4hggTGrhP47WTbUQHvt0O2S5X6XcwQrISYtRUkevpI2cLXhP4KzG7h4+OpZolu8vjkT/wrmLI6d04ey+n9YXHZe5+x0vRaEa3hcIVgWYLUgVDQ0tU1ToQWI8/wvyklZVpO5jpeJOWIJT7N4Op/DBVvRTjwoWk3SUQh09DmRu4hxiRBw0EOI5rIuA889L3pXgOEi1bnRNZUApRI7h7Bo3aeO88Xd39L3LDKIrW4oEviM4wvo3WzGZzRPWawgBQa4aSJRGxFrDCn8XlR6EBOsp/04ZlVpJL/ga8Z4bk51ze+BmbJQ3V1TyXuJPfpM1PfL5hZjsMLSu/VidSQ8UngMHmCdzgmGbrOiEYrwx66BPFUPqxVaHZCQTTwQVC6setOnv7+cC0MK0taMPlndALetRSesWe1ATU5bknl6KqEQg4xktBNAa7Y49hMA1K6tB5dYb/KHOtrh9RGpQV8QQZUEo68oxya97Z3MYkTA7zJm3ncdMxsk3kWaIQrNuDh9aTrzig2DovJeKtE0pQkNI7EePACOqYfjl8UaayFK6/1YHmy08bSC1IALrZtCh6/EkRKb2wRqkH99R/KhQKeK4Fg1dZV0owf9FXSpsMV5oZPRpamQsml38sRfiBLg4Y1BC/lDHvzARvlLE+nJKwyFOD7ipxJhm7HdkjWxyypJuxwXOuae+eZGm45ewHg4LR53N7dgfmE2YBWCxbzTSHMX+5dYmzcXLU6HUI2h68Hio6hT3/1eSzobHc6YSFXFM9HKJNkkkIm3r+TgKrEGJPtn6z48RrAtnaHwyD94wjSJ+tAA6GkoaYqYhV9Y6C6z8c1347QfF1fFABe8Z3BhrpjNpbiOBdkoP8R5fKdFp3IK0SS3DSbgL20aZrkWhKWUbvkjdGQ3o/DSzVn3IAwCMclczqkFeDz7xK6F8i6WKDMXaImvUL1qFsvCyEnOTRG4tOv2QZVr06X/ORPFjQgdWnhVr9JDeuULKkXsRUhvS+liy0LaDqGp4Z94Zvm8kkxZPZpt19D+b9sp+k0Kzu3iRrP0o2vg443yl87+Dm35C1v13ajHZR8EEy+/0+JDhAjEuWLmm7dXPAh+p2fwaGi1t6hDxZvM2uXUbxm2w5TR67U7FJ+fPVGa4exXlzxPD7lsDGsMVs1n0XlWTiN/lEBKvZTHrf0+sSNn7quIFIytWeQZDDPAiJ+FVN/rJaTJtQCJ6VRo9x7bhezDJ1cPOS3eYgFrfqkmN0aUD04qQeKMzZmOn0vcScKMaS6CveBnt8r911PZC1LJY9nxzcN5H5yhOHb4ytXCWgtMamAowHn+U/8Kj1PNHpcZ8wAVD2rgFS8mfURgnE+Pr3/hNQwHOVoupnjFiOHeBZ5VwjcJagbI0EN+QS8ALxUjDI/D0/F1oD5azZcU7nBu3NEOCy1PfIvQJr+csNyl7NeUmBEKZTrPaBYSo++mmhGTb6quXTWZTt/ihHulA2TWtflXD6AGSfiZHzH1uAL10SWaIj7qKJPIGUBDV3O8u5vhKTBIyguyWHKtI0HVGLzvqsbgaHvVjugEDwTudO50f7NFMbj7ASfETHcbq3ncUzPZoY6Dv04fIg6hfrqkyLqKHVlOCKw2xiQd7/Xhj55ANAs9d64NpnUu+ftkZWTF1YXLRUUpwH2FLRLVemA1f2fTEYGkU4rJy/nkqiX7rzv6bgWJTh86tp2/xBgvoa/f3g4Qgend7GDCUPMbd0rdgOSjg9PohM4F+OdqjgROyR66rvC+k9YnEwaQYyeISMCs6UbGYGEP1a5FQwrhSXd0vN1z9oY9+gn/H9pW33d7x4Iv2NYm8BtxqY7xjtcDvSPbK2QGJ0gFijg5Xjq7L9mlJ2dkjM7f0eEiT5/tH/3eicz1ysoHSsSnD+5ucyXwObjzsTHxNsYpzYsAmveUUxYSJibmF3cgtkWwk1KsOEQfYasTL2SiOjV6xoY0op4W9msc/G8DVifvHp07GDXIC1aU9c0F4OGcKfQo/470K9OffYgP+faoyS+k6f2DD52ALTED350ej6lLt64jdvkNhClQkhgBY+azSZPkTe5z3aze+b1qXZRdTiq/yaOLIu7RiZNsPiXQYsjZGMbgIANgQnV6i8LGBg4M23BmCnCvKJ3xzrqLaWpfTDXhRn/TKJTufPLZg99R3fpFJkO7i2g6WKPVwDd9NXZKRVCKnU4g5OyPhw0rXgjQWK9CBqEo0KqbiauF+6KGYunMGSMCGZx6kfy/pyym6iAPf2mepFayYewA4ugdcFh9sfKLVM9QAXDpksyfw433z+Xa1XZhFsNWqvfMMphz6qeGqXQjOgpi3CHCyTfHzxtsh3gJEFesyOWMYcdtuh3TzbLeCDQ58gpZWeaSKXvx6lLCsR2j4P1F9tePCsC67YjtKQBsaDfwSJRPLO7ZMNsfG1elwcQRW+8+1m+3d5C/49BCXhmB/ohf3RakcAQVudHocMjDR+OLxdx9ImOmQTLLxMZDpVLZloNjHAvr2q1HdsdTaAo6w4vaP1ox1WEZRYo/r/XEi3IcHTJFUwPp+Ko/VtxGs3yfzCXgnFm2PMCdzoQemqKLJeVntjehQ3eEOlm3A2aMdn9neuDVeOoo7PBSAyVjEGejPuf4YSFrLwuXnlECSN0jUjx0QOn2kvxuqseefWFvPt5TcA0fLV9n/voflpAjARMr8lSufkODOOpIqfZRhmPV9a70aLDBQgxxGj/f00SIsgR2KZ35eFI45E8w8+KA8xxpa586i3nUdbysg7y8EdCeQoleZ6BqCWNSc4EcHvAR1RK9xlQb4A3wqentpECUA8Q0rptOcsLSWuWocPvEFRfGFCXS/hW3EuzvKPjqgRVa05qo/tUWfs2pkal3O9JzbZltNb4YqT4x4DpRRfQrrWbR5gElX0qwhneIzM1OMZeOuA+0NsvMaAX6bZqGsSlA4zPIhyGaoA/ObOTRcZWBs9NIBSBmiELtA5hHKfCeWIbZ6mlHEK07PBPhqwttU5fYsfQKfacfCwz5qsd/OQexSZdUvQYbzKedfhMQ2O4KMJO4iRz3b+lZ8g9s+gioeI0GMYkJB2yCt2vpeFBklJncxwI2xnG4TqB4im0J8a/tHlLClVbGrLgJZH6h8iHUwGEtpRyVXrQj719JQfoDYwcV3Z1LEFk+8djBVkijHSPPyPU71PtJTt6DYId09PghxfTF9+1ZjzUNLE8hspSwnhczavRPqZBBYJM6dui3+Zh+XsdccJAO/bTMi9VxNCKsWUUd+Jfte2fWM/l1QGXwj4rAdcJb0oEyNjZ7f17jZ7pvm86p9YVsY/MDVQOdpR9QKeaUIAnAmDhT5romVpjX6VnkwKCNTWEBVHhlKHzmexTmv9vfWhOlCqVVdPM1YV4UVRtEmmgpoUOlx1qXjXACcL4uIDKWzRrkUpRC2FmQoEYouaJrxXTDvtmcYNekjVdM097OTrR1ZVSUyZw/ZFHWx81Gln7OtJSt5QO7cog4DxNEFK22nhbWYZTor8xu2rri8hLi0knfbQ2B6dWKZwiBVvUhMgWBjDsAL8I6M9ZFnl8cPY2Nvvs/QZaQiY7sz53e3WhwlUnTtgbZgMKdEByKlQEFb6E3RYAXeopBSl04oh1or9PzB2BGTlzE/uF6fKgtisyV8XDhlTPRMxlL0VfaNSkymIaW++xs0Oxbmfr/cLLBhL58J7CHaq7HkExrsD7K0EPG/bFsJkaP5z0+KFYxMJo66x/4YRMy+QZ0IZLcNZpsh/4H3FR2Yn0Z2zkfWqV+pyxfte9DGhpFIpF/iF95uMmd4Y6sUesw/qNsr9zNfPa0bqsLEfgJRueE0wvNbEC39TmJo3Sas8fXHpW6nv0UKnlJqR9/Z5cQmzzv+sXYMVzqG5WybQBGsrgsV9amplAQEJkNDaeZUr2sxrlJsM+zrYyE01WY/Jif2TkXrNcyLv+kw4HiF4KuDJAwh/BZursYyUOfyL3lk087pR3TRY7N90phkUFvpVTUdVSyzFTpUCQC5MNSejLCOj1n66Er8AxaBIYgK69OgQqT/8eZ45bdKwBrolEssiFMZKlpeqWEdJO6OdqS7ze3jJwqff+hqpCA415zfvxrjLuDviW/yR3Wqgeu/UOxSHYZf8uphu2pPMpedd+zwmWi2PzWm52wN7AnmvetqhdGH0Zu2T9rV4er3NFj0njApNTIqfzoxm7vACqDMkappLXnZluIm1Dd+xSESYSCwc1GjXK4pxP82iKzpV+ouuvVIIzoZ6QnhaouSFAH2UG76XRHK3Bl3+KWDK2cTLtyZqHAvqikCW2NP8O2Az/S+JQ84Oy/JcUy5PoN+J56jLKX3iRmV8bOpY4vJ7IOn+AZG/63SWznk56+0f6JDxrCOkaRSUrMFOheyRZGV9I9YivxwlfkGuzOreoXQHb44N1aM5eA63l+TjAlV5G/tdELxe1ghl8O34VNq5ngILt9zBVTrLHPc/ZYIbepAfigcjaEFYCrgA49i9ICdqFPX5t+vKIVlpCMJARIz+CppYKXoJ9j/8XEUp3+3VTnMkA7KnHqox27BlJm6Uam+Ebm4i4CAjj2VSDMdWyqkJwu9TD4TP59W4t/VTdRcUimHKsnq8Na/gAdz5fXshaLwuLII7Y96G1gpZpLSaEu6ke1ALlD3VN29O5Ey1lR9k0GfeekdYkWwPT/4hjrmJ3xF/i6TxwdhJBZP4XiHAzPN0Fw2n/GgmM7zr2BMVP5UJq2GJZmeA1RiWf/pzKTt+O9ZY6tp6h6MM8gNRgxQdaJhkJNfX4ut1G5vUITUx93dK6y3AYq+4nBpWMmTyqBWFIIqC7ztAu9nx8BxQ/aW+3MQHGdrGt2ECl9nAgVUYTkIwWXlDAtyeZpxW+NL28KA5jScrKmGAEFxQtjtebQVpBiPqW0b+NhPFuFIw2YBAlXGWdSI7vU8VrIl41J7yE9lSS+gCi/F0qPieW+ocJx+PkFXM/OrB91NAA9bjj60epppyTQG42kaINUb/Ylfjmu+vL/xEWmIyQY1JtysfE0vp2Wo9XItyaAd8JfCiKRN8YEEgqRXDnSa2byaqz6Y6JSCsinDwp1RXlagzJh969dSXoxuh+35yoNZPxGhtZwCc3wwVdN71v+kJB/KpbmAQ6q8pjUt09E+zhVYONefp6yyiGWS5IU75Y+oOM0Qc9H+MsQ0hAU55Z9K4UGQO7z42rR2izf+dQdobCsqcEhaqvpzjk4mGCVk7wZ3u23tkQqaO9UcN6Y+57v40Mpd9bNNt7BM03d3fmY2BI4Bu34H91qleB/ZyUHUlhEjnmORdUmijo6hukrlcGcQcC7Qs/9ereQg3mY+6azsqMyiw+M2I/m4hpF1NyGV6Tc5uIpVG/s3z8SqIblxeJrSc9246HTpaO0EEDgQJqOdZDRkvUFgU80w5QuTBIaFymR5//eEBJB/0O60rfqpBrVKHyXcuFZO2uqS2v+LqNa8ZgfqbtV9buJRWJykO73XaXlu7/PrzMxWGylNOGv17deyG4uL+lnw3sMk6OKBXGuTchBqaH/cHqq56FZcxayRCV2P8IzqRTPknM+mapfM4lSYlEIQ2Ni6f0B++BF4o8eBpxUq1IvZitIrVLfvMiWH/tuuPhFQe8SHbS8she2d6q1WEKibOLJYsR16y4tySIACMBbIENXoKxGYEZzHdKNyQTKPktrjDM9bOoYL8EYNaGb31hpKYsQsCjTcg+m8QTJnyblPokONVsxspJM06IguYprPl8XugRqoRDGFxN+Hbb83ubkHbcUZ8nFkS5Jop0XcPjD1Ii0vT5+jB7CjHA0NsCq/Jr7Fk6TZMHkyF77wqU/A8Ydn0GLW1Yg8YEOPAEtdykLiIbJB6tPeeUVkSwSCswBvScGdbMmImenq50q63pd+fSsibvX2wVJQMgx8RaFiaj1piGaLCKF2opbGaSni3ByUhYg6w2WE5qfUiBz8zAyyLN2Imk8/lYg3V+Rqcf1/JuPvV/Klwh5kBAmLTZ0rpUDdLJ6SCKroLBNCefC2WuoBH+EH5a8A1DGqdDlh6Dtm5txSBFoRCBtIKEBHcos7yV75hHA5w0iQr+4Wbz9x4xpBFP4YfXDoWaQA7kBMhikErLBUTyQ1eMVMC5I6uticOPuXUm0iiIS2QiU4XiRUqqFbZGRrmMbZpWH8WAd2fWfueVD4sqld0ThkOzIkhst+y/7KZ0iesZBk7Fa5P6vNcJy2t5i+cwqyJQzUa33EIg0EsH4PEr2qWj4y514VFUjByIIZVeg4HOjKStUClZXfjJie1CIFO7Icl1Dqg+4HcOpYl7LIKt8knk2Kxs9dWQx2RKIiY9qBZd7phBIk6pFouhzFAyzOnFlHA+nTxdIJyFeenDL8/VkcKRaZX/BzL026yOxu+DtrfV45lmsLohouGKKbkqratCZi86ZEkpibD9MU7fxy6OnrYqVUqL84vEP3QWSP+IKQn78jW/G2c57nNqTUVwXsVcv3qv/Z+JcWGNa8Iow+uisPSHGCLb8pd8d9Ekes/2jjrjbP4ZegsDKk54HOyC8oh0itn6/li++7Zcd9ZUDjqgGpPeCFseOw4r5zIQLmljJwizuiBjn+DgU5pb0NagOH1Uumi/wJmbjf5shS899nRCl8Qv9Hcf3VlBIHqMUJ48qFqPCqmexi0AgIMQDyiEHcvj6VQbjDm3yBzuOgWHTeHKAWSIZ8e1OvCHvdaVzOlPHGgg4NJLeJF642Cm/zyEepgeDER2x6QAt4YfNu8yv1xn7Up0Rs6Aj+gErGxUew/ls/DhjfXLjq5I8vtqz4Q7VmnUURZ9U9pIOZvM1nCCynh/LuOg5YLNWZmPmj6oHJTeZbf8r7MNYRr32XcrEPqT65N2UAVvdDTpJ0rHevoXjaZ3qh0yxLMPw0nxEQjWgoKQekJst24LTig87LaCdq2S5Zw1jBlg8x3p1NVWwWIKkMflAoCuboxDtwRXCdi8p5G8IDJO4Nm2qstgPfc0nvOze6SBjFQRYq0jni4yMYM2bNhx/OANcAYbjeZLUzMPBOOo/MvCc7BnMECgAWn4tIRFtF80ugpCot9zopUIZBSeO5aojPk2rCwBKum5qfEdXMzB9MNsME51bCKLzSyDZ5iDr3LlSsxTzp3ecYqn/zssRPFVplbeCSNXGoBddo8+3ULIA/92oLvn/lHTvNnc9Zi5k3RLZj6zjFPoc6GKfLVDz8TRrcrCQc4Id1E8r9EqO4LidptH8/onnt7/Bs3zHgir0jm6FVRC3Y5EpXjaAxbHdRQna6kU2iNeS5gySF7Aqt8CcSWMjtj/LfJMPLpBgahHdHRl4sT4/bL+l9a9FRlDsJgKuHyVvoUeuA2id7nkuI0BORpM+e7R2lLKRu6dI1NqKOqUQFXBalocdDpM9xZiPtyPIwDYka83MEpSlj8KX9eKie2iV0pTwdF5XNON1YUIsOuvB2tCwQSmzx0PQn0iPHm8R2JHwt+61/U6uD1FKnqxqtkm7x5j01fBbm20Q6BHT1d/K1iwudy7RAwSD4r3wPCGABeo+Nt5tdKr+9pa2VNFffKWIbtfaFrmC3FT6LoNCK2ClQKniXG6S1ACQHxuisktaIG2pB3R8deeM/Of3MFbZCxp1kjyg7ufoORxudBHKy+6VPsUlC9ctNftBDhRg8D5M5JKKGYqTF2QTXCgqAcp1M35ewJhR1jsSYpOB99f6pkP9MK4+ZJHJuOsY5nOQ0PV/CVANDTzc/ofMuj5HBYNVNZ9tO/KqD+p5s3/Mg9BgLBPMYF5cqNER0Zq9IRlNPMI7mCKqz0XS2IiMV0lcrBVZrZxjexRHKYBlq9FXxhvoRwNsvQrIWAnWR7jD3A6AJINcPH3NEccDA67JugcfB3kXte6h1lsyN7dN+5BDfamSn1PI3AVxW6sBgUgI4m1ohQ4UkWP+IBTEhz5txY/cxVcUo8YQ+ONpzT2S97T80aFoZzjWjC/eewsqo112A6+YvBWXtg8RuSPFxICWkff1qSxP+oagXEiY5kx2AX9D5P30jQ0shpbJslr5B+FDOBbqroIu67144ZJYuzZ7WoxNwV/yPdlibxz6GO3dzKUVuCL5BlUIRj2CDf76rQcd9ElYKoZbf9RzQh7l/J3XCESVhMb1o7WPSjCJc5MnWsvXSlcngEBjFw0P3mSl6sGbqVragXw39umnLNnV3Me5PmF9o0Ycl/ESJ1npwG3udkm3pyzwpc4Y0ifokcAsLFM7kQziE1M4uM0XcI5ay5BzJ+P4QDbe9C+NnoMVbfWEskCiBg6ZTv/ZXpHxILdIY27RWO4OLXYMeYpu6kxDbwtFbYCIEbePX/NFiWJ5VbJm9Qkn3cKJEJjoDf4G0iA9bSOqgShIuYH+g8CJtQxdmPbghGf9BHyTCMe0kgwORU3/IaRCddO2Qhp3LWdEOeVcNmw1Y9xP8VePeL+TWI/s/Rf7xkMo262XYSFPRdBe4RSE/6bQ+WWn/ru5+kzCma64wVRaHF17QBzRhpC0+wgFfKpVGipV11hBdRglLvpEvyL9Po7KnD9ViGqJOluhyzxC6H1xHCaYVo334XrFyWC3WrrXuT98vSPcb68k3YwJpua9K886l8b7bOpJn3syia8VupBWrqvCkckp7/aTeQXP+YMB3VlWfLEQWa2zB0dWUQTrt9B86nr14e+DqB6lBf/aExLaNfeAYXhOTZOPXiWc7oUnQrMxE4tco1kp05o0zb5IGI+l7Hmqm604VibBR/gokOx5ktvFO0nOQv11r70lrKzk9uqRQQH0F/254FrULQQjWlpUktchGFnFlVkN5VlCJC32EHE29pcAW4OMgpvhXyJCPQboW/PteCX6jHOOf9B1/S43m6wVYPae736AIqKWBmMwnPRiHk8nDwSoWI+T5LhsvNDBFriNBNPRHITfBnPgj31tkISSNWV8ac7p4WdvVleaU96ns7WWTshJKcafijFLpKvMDnJ34POjX4w4HpWKBd2ould/bugM5tUqhM7v4fuRmo0Ur4r4G4yEJBExncGL54TiIA2q8TTlB6tC23dceKkjjxFgYv3JpMeMGQPuw716OSq5QXdmGQlnSJjUxFVK7g1r/1Dn31LniVFG0HALH+/KPSSbIdmzv7ZKoooR+LmHdRDiAw3EstMuwxUZgH9QFqymnhzQlES4/M3OrFjuowhkEwjTCowCocVDkABB+z25jIGQ9JPfFhLI06hKAco0W71FKFVCi/i8jgD54hM8kkrq87/KkG2BACcoMBPJGJx0/w6zYvy/LxOL4re8Yw7f9bhoRNXGy22s6AvDeC1e2zH73oNW1D3Q7Z82VVQpZ7G3jKAdc/PrUQF6kUaPvJoQz0hZdML57ilmUj+vcxQI08vEnVwSpyZ9yJ0ENHp1cwJaq7hBE2Q7CHAYjBGtowdTWxtIy7DcNS3TSIvpKsRFWcmbz/9GKCZVcsLLcDQs7XJuceyntxYoyaCH7B+a/2V0uFP3NoeCdU4QlX1fbfvH5rFRbWI6I1FDDC5acjQHQDfRuxVquXYH7gVQjUUPHMLQaU+QZeJ0Wpp38DmWrlquNCShONXLIxn4HF3WM065bh2JPLZ1l/h385OP61tpoQQwKE8ymenfTOX1kI3V8wlDeS3SmlMj1isPnZ0jWYKqwNxylf1uATrfmR9t/xTiSMvTRQhPrvdcMsaQFBGJnbzxwXpUbnt7YCkYSWZG33DvHK5XLH9Saant6RZq74sj07lDGX+ofnTJI16MjUqn8MIQfEsLLK8bazE0oe04ZuHLuCp1szjSi6GXFiM+QLcLZvaNG7z+xTpN3ml8b18tpgG9iZaOZAxAxPTnTzGo79iSa291tqrhGwskA4kype/8mduCGKbpthXGgR9JnKKix5BX3YSaltAaYmJsN22aNT1A8EY/V3xZv1uMsg27dIkCIonkLH6+BXHKOaS/SbYeokPmokbGg+aqpGrpRh3uGWTDBzz0I94w4z/WTb7TL7vieuiTDwb6plE3EPosILgvf5rRwOlzsrqrQkAxQoel7snbJZyz64wum3evfKLDsugMjcWMM922HfvwEJ8dSe6SVp+FZaf8CHvSc3SQ1ZpiD7i2PrcTSceL1a7iiVoRbyaSg1AhWijhmlbCN72QbpvopKtDsQFYYnzWZlGwOrD8YVBzCmpsnb0GV1970SLtyizBuJ4cOrb2Qul9Y3/KDE/Px9i4emonfYLkC0AybVqOwQ9/J/fEA0cNfKClbHUNM4MvKfjPiqlLLDH8Mprog0f9Y5xvwlTyTGibgPKIKxNY/pWvl/pQzxVZX21DjSpwdmiMShKtmaGVmHuLFVwQpasp4/ygz9HkQC1dclMWeQMwcApSf9srWEGO3832g3oW5lsgUHohYs1JlJ2QbbYZJnFuy+t6Y58v3Dl3MEOBk5dJjeJ7YbTMU6Wr45kHHKyRJtPgUVRO1FL2DGSGi/JDWMF20DV6V+cjPY5l1Q+e+GF8xuJ+mTF0EJi2Bb+vgU0tKfhaZ0sYBaZGSE1/2HIubrDTOYx3xLL/QWJ5XcuF7Tknwe0TN3WpQ+hwqzoeIE4+4iGxYc1+kWaiBO19TAyZE1Wo2FmN0vt4RaQ8xmf/OMfgW6Hj0fcKkTVAH/Yj9XgL3tQpyEQx99O5MR8Xs8+0yP1ybJ7M+qjPQlIiEHvWpPhpXDn8L9oAykgVB2CNQMmi+2qF7QH0S5QEfKOkz1j+3QdxUKsML7AtZ5mw3gFzLUeOCBvLHDYGuPhnsQgNXhfbaq1xCtRqccJQ8iDl7fjZ62hYiUX6mpyUggt+MQqt+kX6MAA19JxA5PQB71xmC0JQ11Qdew84sJTNMFmrrafrpi9PSJgb81Sv4YVPINIFCZav6zZ9MMeQx+R/PvCiTz2yVKfjhb4o9LEHBogdZJY2zzxU5zoV2y4f6C6jjd/7X7eixDpGMo+4x01HPfVChQ//tEsHPFqmxnkaDdjPVqgdnquJVLeVmpRc0WqX43OWeNseYfh9quVoxuKLV9Wcq8MyN0wVdfS/3Cn+3PbwUhlYXuZkIBjwTYyVcvPBvLpCVWwQxLF2O5jSvjXKPvUPOJdVWeehs/PVDDSm5YVkQ1EFleoX6CjqwaVwlZ7fV7cfMosexuMIih6Hpfn2oAQ+hyL+ZYQNar6Zh1DjccDMTqhRY1dYvymMv89uk7kKE44jVYROe4T5kYNBHAOnWAi1t8l69pERvGqRsVgvnU47e3CijHGQMHRDTjlDYKCBlVUj4tL38hA4ONrPMtQwXshmO25BhmCpYQa6RVQKK68gQiY9ngy6RMK0tzY4W+6Qf0+Z+NJMJvQJc2B9m4NteCpsTCZFJV/ZEoH6XClVxFeH6RZG3F8hvp2rs+MkIE8ru+17Qu4Gjzu62HYBpXS2F/5fkxvUXnVfQyftcVP3/mbWPyz1tA3roWsvbTZjhex950YwCmQEkULzSn3P8gGhZVvrFm+c03MhWRl4aJmlcGIYORwnIiW8vHpAnMQTY7noDHgx8NM6UmEGVtt7gY/tm6NG3NCSgkM0ICFB2qbOAYDMlgRHcB6r2IgJI4WmXkDDftMT3K83uUA8m65NjJ1RKKc/L+otFwo/YOjLQxsXsTqxadOpCNEaenYTOcD3T492Q57lmzgn0QV0qrOE8uedVtOY90D5F2FZzm6CUudYR0uiOtZvs3GqY/CLEr7lQbQ02IMcpExgsJ1Cnrny4NXI3jXQg8hXaKgGNmA1ZQ4WlhSAOp5nG7BJi7IteLcoL4xfJcKkF2yi4IFaJ+amovRa3MuuLS9c7OqwjDAk5Woa10FGLf6/nY5lgMFwZbyPwe7gUqD9eb0KrYw+tHm8b02RE4iTa/kSmDSItjUIqYCjsYRB4olLGOfXQVKlaBwaalnNB2gVQ0Z3sDywp7QjF2jnePhPCWE5uFlvu2LL/BhBeG26kBeXIc1oxv9QFuvN2GhoV3lfwUPBK3E65bWvcHEfMmhAqg8CVBcOH9PI18KgR0dDQjeJwoa6BYLZ8QsUR8BxyvpoxiJv1hRcZX2SaM+AiaSJzH9RxW2/x5LoTjXHiTfmDVvodS7uxeZ4euwsCPP4gP7MGt91gXowLuw/Oc8zJhW8MBRPE6FgKU3nNWtPHvf757p3h+D2b+qUZkovmnCtMD4s1x21k8rXciQplPLOxG8gH522ESuqVr2F2eiOpc5R/HV222es3WlkZLfbINVE2v0at2xLZwQXYfJMDeD0pWQpCN9SaycFUId7mcRhO0zCgZEF9sCeH/HIuFB6JkCqE0Osi/ihrNuotAff8rhVUk9/lgO4sJZcnychzbAFKOUYmJ3giWjZnFhIPGnwGxrHZxtrxtv6SGxKIcMa318Es1VqjL6urvzFE6kct/zaqNsRw6aSsu/+IkS8mcnOqO1hlsCbUH5+EqsCErYbZ+m1qtqvJUSEe1YV+P+nhGe5WqjiWYl/RcWCwxWzp8i2kKPjnRohnxTNhRbCV38eRs2RxbTobQzKv7lnliBPVF5+R83JHXuKRelIjA8BxO4O4FV8mkd124bIFrfpAitCYy7BD4gJM67Xcin7UHryp2nmoEZD9UWPyzQr3Di0/siGZzxW1fNnDuF8Horo2uoMhqAUG0rJOOXA5r/auyjo370mhdZugOTSCwYJmmEUI0Xi7/3zoVTjEQmv0lwv0W4qNvv0kJ3JlG2eEg/pe952YoV3YobZ2tpPlblfWzEJawtU3BcSkRVe8bkpkaYTLRdRktkxS6QYRRcMkvPX8GwDuR8coH/Wg0vhi6HtJjcMPsmEZTWYSpsMlDcUR9bKSvnl3x2xz5JAgvBUpMoNohNuK3mO+9wGXcEdOxsVakDPaoDkL/INHc7rKBeStYGsL8Fzd1I2mwP4WZNOWBKE5BbQuiKpiaGHexIn9ntR9GpYh0nMc+4yOi9eHIVABwy6FTNSKDoMWRe1WM3kQhkM+ioBWX/AwjTGK+QpO3L1RGTjEd9GKSROYJToE0Xibs14jbD136tYIlgDqkFRR5NVjHz/0zTzVoDU889ri9HyCQZjSWyQFoBIwqsmvywFGg7qmizzMLmSNekoqR6S4u1bkqv3ZKeZQ+UZ4qexhOioqMyFKWAFCFJ04sGslrjo3W7QrPgkxFet3azztSRNNLGz48sHi8NYGy1z/WlKh0ZLvxo6cNTs2m+EWkUsQVoBB4ZhSCqq3IdHGb2ON6mK6pZk+wQzqdMDoEV6cvRbU8h2GSUJv7uiImnSxEvYmVc74WuKwOcGXasdgdA31hNLOvCJ8nVjooM5W852bEttuDrL+XDZ5Rgo/Pfctl7WKVwJKMeKwInia1cD8ZEM5awQZ9AB5/70kKs2Enra2RRRf9ZbOdM2gcN5fZRR72g224K9Ba0TpKr/WhX7wATP3u/wqCjbsfHGZFz5h9qlaw/NZ04nrkd2aPbelXUxGklkmjd5AsFERQbB7kGazbJHFzUmkqvL+uMG/XodihIpiagRx1Zb/2vZBPnw8tmR0SdSzGSL1tygUaaydey4FkaeCb9usk5BIUJD+8HHuNmiyi+q1FqjRrJpdfEOoZhPLELptJkunZv1/rIDGs78LVvBGwxL2U/ClhOttNG8lI9Y6p7C37Oum7LOFSZ2V+i7Ky/bGQf/23orRjCXj+VmFO4Xn/WbFJ6C9FQ5TTqt/MftHjNBonLGNUyb8GaJBDirShqQ7Cm80DzLbiZ7zoUat5+isxhOEo0xY1vQiMmO2BGLqd3PKwvzFAyyF/K10XWJ1FgKpcTAElv3H+4NE/1fECIfNE25H+BL80tm863l4JgFxk09NSxEysaZJOYdciJ1AO+lPrtVg1orHSv87SstTps7IcpzlmxjBbo27TPkWgE1Uc6ouO0uXpQpHX2lJmAioCi7oRDhfWmzOXyqLQn5zQDzemm3qyteh6Ypv0kVI4AhdNWKzBXMAOdozpRxmNbLWygoLUI+o2kMMBwv2zxNmhwSe6chTqjXc9jU+5ge+/Oj7l9SMF/U/5nomvgj6J/YeFExnwxsA6z/VfGWHy9HadSfJKjXFVJ+PQWULIM/ip37lIirBXrGgT8LI963lZPOCOf17+PuavW6OcK+ZPOcosFKQNc/geu6Ab/fZg4M37+dUnPPMOODLEIqaRdsHNuVVt/LY7M5X2P3SbyhjIotef1gR2MDFZdbfTGD3bhJgqzAIX9OZvbVe62ImZN4Ixlhp2a2M4+/xYuiZAvKCmyXxpi9f9D72bowl+8kjku81HnbehLkwfTRemV80CP3AgZKU2INw2fOIg4mxT2+kG279K+R+JVLHnpse92umIWsYZo3GzLCd1z8J+/cozGwtSHpbyn3VW/ut9iM2wK/WrZEA083tjsVeyFmRR9uOKEO4evHnDFjhKz3vbvnoQX8tC/6dwrpjYD79zQ4brDBvSBRbUE+qlX13r5YMUsp+8SBihjzIcO5znqx2102qRgCjOp9ooZbXb5xe/Bf/2zb13UKmmHFhtpmHK+z0DW/mnqT2al1Hq3KfW3xFukOKIpnGT/eHgewa3XHRru0B/f4oW01shrJexcp7slmKA7oYb4e37vWTTe/k+5l4RKzuaWVfst3Bi3q/8fSMLaufLZuEHFvGM3YHATIVg5sgXiyXkQPFnYZz4EzBrOlsZ4BQ981TJ4w6pzZM+0qKyhZOancQHY/h+pG/89WiksgFiGFPcHYNtZOgiqCCIRRTGDQv0YRZyZtri1bLr8dZapiTUwJCWdQ/oalcOMiWhD/pmgdVs2J8kXXoOr+QDyVxCVL0pyTfvSvgoILgGYDBOrjsRdk41cxMznISmL+GGUo4d9MGTD0OVfiiJ8sHMc8w02fPjVr+EuDhBwG36IXrqaFV0IJh5wbZ19t58YfRBJVDkD6qOP+SnGIlRIAmO5X0z6Jtd3O8co1c++tuNmKEKGociM2VqufCFSLpOT31/NH862e4L9dnbaK8doQluDj6ZaHcnFGaK/rJ33niiQItXWDa7NhapyUtV/xxB5vgU5VRMtNAT7hA3DmT9H0Ok1MKt4+rOjuY4GGqiqVx21Ut0ODafCVLzzOKkrDlqoNv6lmbMwzrTaolB9O3K8nXuNOpvYhpgoT/C/7lxT40UH94dm/OR+g7aHZp3H60X519SlZEtWnZq3Uyljb4sCzLNqniWqlKLHHzdl/3ED0/Ky+WEdRaf4qUJRZ1MMW3xEDvRm9Dm+/Cwa78nCluKBGY8qHWceNQ7D0OkgM1fmn9UcWNRHJZOWTUL/GMjmTccgykJyLuUvT6A9p4XZP4lj4mtU5kbiJ9Ug1LKpid5GV8sxid+L/OkXFQHFUmiwAcUmy/RAz8LukmaEt5SNJ9boARS9hfr/UCFVQDJLIHaDAFoQ/kzGUjIQH3I7iWVeHpzCwFtR/UiIchlI2RzN+BmskHUrmjKe1CG5nx+asgtnuOKSV5h8N116YfW64CKvNBjzmJC+3CrttFlFx5h5F7QwmsB6rE3Fy0kkxUvkjGJ0d9OwO6HcGSUOBIpAuwR4GwyuSgN+Dj46A7LNkKPr3ZO9ndV1jNKSrQJwAjQu6iH/BrU2hxg/vutJTdAzFpeWRgFV1/CPltqckla2LvIkEbOHlcJZQKEr4UlX9CN33eKBPLEyWxZ7f4LsgOFJkLUOSnnAiEuh7fA7IjiWZsR5ilUa3sqj/jx3z0zYS8HHvwZfQuWVezjsfF+WQYWVs4ajXx4t/mAChCEtp3DMyYOxyIFiVio75aD73rUdv/ZPj2NBmBd8UGoMT8WWLNBeRC3L9uYNqkt6ikHeJyQfBq2Y+U3BeN4ca9p46mYemQY+9Pu2eAYOqFFtW7knzDApDyVTqmNrpHa+PU/Mbrl5OSNQMbMWHqgzSCWs0XMINHYGDVMdHECIVFkkq+v+L0fFUU6K9xcg6ds7A/9zvNPJPC148JDSWYc0/1tgC+FxmeYJDDjZiE7KzGI1Zb9WyVbA24+EEWUWQNFsHm3xEGVA7zj4f4nxfD6Jca7WlLOI8Bm978K7/ttZmtacMpOQc/dFS3kFYDlhaTJYLfAXNBxrneTTt5IrDXThGZD/Tq+YbL6mx76aEcZ554fHEuDgkF3h0qILy3JKAkStLSLKRNz9bX8S8wSVLFMDKCh9rMy8tFR5flaBzPGZK/QMtFTLUxY++ezEACcRm6cjDRgyM77HfZmzD+aDB9RD2EI+lH3NfrQsyuC2RpQbyhNw2zyey1fsELJq2bebsrj9Wg9n0b8kTSf05kFukAcLnqTq97DsD3xygG0J47o9zyNdtrLde+2nkREa9AtjAlMN0TJpal5k6HTdxNo6IcipE3WK9tB6hUdtFNCfHO8UeA/u4+t7NK6lZqLkDNas4x2xyNtABISvJ3dzUmICklVmVOZvBQxWXqRJuz+f5de6r7Kcie9T8TH8SVhHOJqcM7i8D2n1oEEaO8pd+htDL6anOYPapX+DjZ3063M2H90h1zi+rAv9Exz9M1XG/1lJiVOoGEP7Jzlu5s+oqlkG0FIj8OtfNCtVx3fwONo4VWiHznTTLVchgOG5Kj/SucxaObFy1iErWv9uBIfzw/P0cUHNRaDOQQ9+wMCN9mv2UgfYCSKz1WAMJov6lMBClAsTCAf9RUwYGHE/4vO9y3mFyoNDusor/uPUUK3dJHEDP6VGk9m+TU4svEyvu6sHgv44cp/qiSxUBdYx4f3NxPOfnRs+kU1wfEa2Wue2AVB5M2w/Hq5fL+YEsTSA/shXXiR1F7mIietwapQEIjcOWAuxFVIqCj7HSkQku/0nCLfQ0UbLVbuyFOr5yo3NQeNpq4wXX0HiKqyorKDplGqP+ErLzlytcO/RB5gcDj3fWC3QuGODDMwTUVdABK0fIdWDkp9kROgQ1IVrglyXA4PW4qQvKtsj9KNHwoMc7zcaRhqDuHEChJVYAV7Rz6ud2Fwlzi11tyofAwr/UjB9R7671hgm4flHj6ooDizlfz+AuVJ00zjUmb4lTpcDW8ZQRDU4GCO2BXGR/wz5O+tTd42St79W6DITVieT1silSV6NhEOQQwASZVJWSIm3B4zSp8YN1a6AquBgJsqsakHU8VEuVFYKJiSNR1dbQvN3zfbTTCbl3nvF/yCnkxkGEizw+1gDIwFgykruyo2aw0motuN8SxAZ5ZiQeQ0juuyjlpfunB4JNIZj5kZ2Ey/YKkAyaAuOm36/oQy+Wf3zjMeR3er75/Fc+SNy8hOrnjDKc7DlI13+z+KadX5vsx8x4GWMsUcFxJ1pWYmKKOFTSvB87XKJi3eHlKm1eEdIuCTbt+Be+/je0SpT5PIDX29IOEim82h0RTtgp4HCSpLLdVSSfYeE+7UnoU0Hob8CdoyQN1tq2lhBLklJpeS7TNNC8MnNriMjwwFbEmGA+duWwb92+e2yXG3oYuw17okrfV7BWXHvpbviccY5aMm1XS4ah2ATg/ykwiobRBK/glCH5PJN29wqRXIgNjhKXyB2IQHA3XUvmemHZvmc7nLQBI7wIIx1dQS3Et9hxbh0ApPeEfyYwjXN1vkIu0/5bYkwaF26YPhnXbgr7QyLWis+TLrx5+e0/2rludzrtp7QBgD4sTmHmAeALQ8z5pqb5kVkWci1cN+MvlXtgPVDxL17ly9MXbK98b/ixZtVV6jGtnwsUrdDHRW1Zg8MFMyOQoSfhZIoRs+Syl7ATiCDVmPTHhZq/sXNf56ibSbaPfhk7uK1eZqhgCHLSx2hUYMYbIxeuIrfEwX+yJRlucHn4wZVVrISpRQWib7WMSn5Wk6zZq27bKIygH3TEDQA9kyoPQPuC7y2UzySm+Py4TE/T4ptN0iitCL1KzRIRDkEoBNCTvKomciNp7bsMYyMcej6uPU0rVUHIb5EPVUZOIQXLtrYJEygqQrgVlPxaW2tFrvWg5YzqN9nQO3f292axPROHZF784sciSazGsBW0dUrQ1RvrtBzS/hRraonOuv+h2WAAmYMQuRavOGjEqOuhsrnpyTumXjJIqTsCuRSBtXT1dGzR0gdAkx3sr2rxpSo6lYVlnUrX9oLfomPGsalww5rgetTKqyFDgB7WwZJiNupV+syOaGPAVWoqg7I/eQjkxK5863U3WnSlT1EInTqY0fdHXcLrjUHoDhuIyMrwwd3XD3P3YvoG5xO7h+2ZUD/AsWrroZSlPbZwLZTRE88wCtGfY+dYK9f5W/P3CyNaQTeWlX4Mfd6mOhNnGaUBFs4Ydpt4wE1ePwDQo0fOMEjVRM66fUf2b0jvjkazRDaQXj/VD3nfNb0ei+FYBUJaMkJyf0kT0RP5wxewvzeBjp+XnhdIILFcO3qxhh8zFd24u4YFONMs4uOSjN+Qw3aK0oJvKzeOuynfHtKS+sOMRLdD5iou54MX7zSTMAuZy0gLGwwxWluCYPvFPZhLy49Q1l43VyCFnmk9zvjRVeuPgOpt3SMr2PqLjFJKF6FedWFDFO6X7UfD9q/TDpPxWYXTLZG+B7H1KIsjs3qyJXGPjyAb2kCIclmlASyknsJRKR+uIeow1FZsnDlNVsFkLe8AXqs4R7coGRroHihEqMN5S0zW4uPC4lhVmDwbOQtRvqrK8uFIEADoOdF/zd0aBd7nH0zZFdxgCSzeE1xwvAkhOIQjLK1pSAseJ7+Y5khwQ2dfX15xn1ai56vXYaSQQShjLnOQZbNMuLbcvXyIqgCsdJZXpH7WznvXLz/W1rGLTOsUvFVRSNFlot+8NMO6fQvEKXfOvssS7kHyh2VBh4tG/mzCP1vaLn6ctgplWwxKtP72j7T0NA9+0d9mTWrBtyD+OxnNIdDfPFuT/8TeQ3ABH0KkTqhp1E+/wjF9U8U9gYJ6hvUH0LyIz1QpkQpL/6bkT1/iw2/zAiYcHLIxsQYswg27H6O7GcZhcCILPZPMsV3ZVgnUrZwrd5Mhl1klSiNoAahPzjtpelHbrPffa6lPwre/umzsSUf6lIiRbnGF9cF5SGi7XEWiQgNso4TNlPkQ0rYT/xIdRRu13/HmS4Lm87a4YWQV/be/1vKY+u8qAWBUCNxog6x9GpA8RrvU7PEMcNHO1eGnrPZBbhj6Bcm4E1ujHe0DJs8p/chHifPRltycc4wxt6LS/ZbP89IMfqmAWN/WHOSM1GmfJkKdgP9qPFIYsI/jM/1HR1JO/rMWxNUz3aKoDv1uBfydVuh6mxMJnDPZUUHHkgjWmVBlcJygAdiYrGtJTgPGGJ4yrd5xk1mpDCJrTjdKYZxncK0RxQtx/sqxMqImStLseNNhKQdwJAyhi7cWhPWxj9sLcfDpha4gMFhCi3yReug7mcp4cI6lWO0LOQFyiLShxLiNNSZmf3eSwaKQz1uVStLmrEuJDB58pV/f7GiGxSPz4xzOF3pqWskyD6LoY0y1zjAYaTebJpDO7JW5xTRbcT4AwVFcWBUfZUj5639/nZWirj2VKLuXESsMbZfFrdNwUqqa84rjUm1QK0MBN7SqhCz9F+cdzzXkgrc86ZDW17jSrZ4X2v8R9SIs9IITZ1GVNHhteNUFk++rnmGK2Z3LrBZyu1HRfq8bBjKCUQmmwY4dKMMcgDkk7uj7ToQ7muNoK9amCCTLH5gbK/w2NegOBwXY4WcYuOW5e2Fzn+pSHQ0I4bXZ9ks7hK+THWoEeKzupji4zkdjGnruv8nC5ECpKXpyvyvExxggFZk1++gMW50hYDY0dTYrk/ZULP+SO9w6lQvEJOUakKRLg9kGqE8hldn/2zCctOSoi1DYKkKqaTMDRHorqYaLng6sXlz4UbLvp4pG56GOdUFUc5ZEUObLnzAy+a+efTlDdIPggKSVOqMLE+EzLspsy0LomSLEvT1U/1qt7cibhWBt5p71Uqo/Rx/g1dMsrbUQq7SwAfy69LXYpCXwLJEIsaeeFlxPjIfFN3PMkyHizB2DNrtPxByPZFG7qZFMZ5jQ7ROWvpIZHl7OBJg4YTrND0jp/w4OzlgZLWyDzL7HEeyj593uRoIQom5x8githZlS3uRWWqYrutlUH8rInR98yO4ByGQLo2SQ0grboGzjQ1unwjSQij62PNs5uju8+/gHSHhtaSZDd6od9ehbK4va7dRV/rnX/XaBQKyPo5Dlop7C/e6uh1zSLfldS2VILgW+SQugeLBWuDoghJ2rbdtOtzSz/z7TdDV5JoSTN6dU5VWxPAdOG7WXEA5xSOYAQWdfIhkSgWC8vYZTScDXlQ1RsnEmFtGeOKbJ9ubTX8YgaT6pe/ehrIfFfPBK9R8FjknNTZ/a4Z/DAcPg6IH0cb/ay3DUWrs733LjyCk3TEwOVQa7tAb5W6X/G47BKzsqWiHLN2U0WdnZuaj0inPSehM+T+U8Oluus4URpRP437jQeLtAWgUgfBvJ0Qc5YxOM6tBsrYe1ksL0KmKe0K1GmYm5S9CN39m/QxdaFqggsDvpbHxfPrAUqf6N14TmvV8XCI+zzwi5DYm5FUwMaAzbU0LViU45TaKklqLne7xIB1bRwvUuaGlWN2+u1wRVSy0qpbcZc5efnZUs0qFPAOkWG4oDIItwnL0yid6dJm6iMWdM0VsC99o3L3AtGqImvZj/0FhP3tAWKmA5BfgHOTCKXLXti3nLWBmGTDBSscuJuhxEL2T2S7mXDpLEsRxerz4kjRxTapClWxHozINXiG1cwuZk+GfruDska2woktkN4WDrjFopVhd9bl0YiJXsn/Pzb8T77yZ2WtjfknpLwiwkgvu9MRGoI5Pcp6fG4osqRUjBNO7LKXb+cEp2zxRJ6Z1AELfPw5JfrgwvGA4WNzQyLQ6xBbZc2OjlvlOyc0ESYPJueVM+gGmO1VrfK4oKVNC3gveWmkHoWM2VBLCMY1cAEITlMC4/cnOlRmOA3LCEnfWwkV5EP4dvSXu53rg012nxMNvGKUVCmvFl9hdUG5H9eReHnbGRMcPZt1LowNEGS9Z9ygItdRDAkDgRlIBKgt9REL7kmD2UONF93vKG/XQM8WsJ7nkoyPfQ7HLB99CTlemCf8Fg4sQ/p5z7dpapVrucqVo5EdBVFG0i7YEq5/0lm+AUFoOR99yxYi2+GAPBKMxAd2JR0A1IzcgDHjFuEgDidrFZ3PCy4a412YuSwmNsGYC59OwJvXVBYeISLGKRT8eYhzp4siBlcpfDfxxPRudppvuIBU5NgT4bF95OmYMYGqFjohltaQ3ecVVMxfgISV75zPVRdJXdypLJHLmfof6oRyA78N8Gm2If41sTXO9Z4l9kMyDWQLEvYF4xJkNZHnJb4mY73w7WR5noxXs4fvcaHzL9XFmI5D2RYmDASIaGEM5I6IBZwEV/Kkr0yH3d3aQdwCTDOY3BEBlUtN6CgexwXD/ZfYncHzPdFtoTmiv84WKQoP/Aibdw40ijePBp3WxXQ7QHSNsS6FFx6f6g0lRMEZuIhHId9iymANUZ0nsMyx7XLEt1s5WSDmIjwBGk+EYGV7j8hEXTQvKWxjm9vSQZ/0jz7uq+JS23FbalVBr0Ln1/xD993/ujZKzoRSIEwmpvmNns0WAVe1eL4VtgAzpBrRSdlrpOsCYXzNhWS1qoQOcV3NJY2HgTvkoipeYw7YimO4vo0M9z65tD5/VTLHQcu5L4eTbLgBFNu4UoI1Cb9LhcGJsrH4CaciLUpGjYS7qkdirPBRIoifH8SdKRxo0o17U6j6TRi1v8BDvo/k7nPr5gZDv/xJh00ZZFskRgwWy/ojPpBjihE1fEL8E3LTZLhuHmYISywfoyQtgww18y4yJNhQg78yFEn3V2h26uzIsgoeDHh26WAU1PVLlDSmhWZF5/pFefCoMewyNfhDlbKLSj2nhM4sxUOHQWcZBAmPlJwf5avfXP6JToAqa120V5TZDs+mbqqr4vFYpP1Mk0GGawkfnoySSK3CoPiFDhaZEO3KWcbtz7UR9Gbiwg+1UdrTZ6Lm9ph1HkwfZsYNOP2QlNCajS1v9oaNHbA8Nvbg6TVEb7aCOjFk02unUMhgzXWJpeqS/uQvc3VPf6CEyonEamTouzu1b8sC0VGmXwYc2/o32YPUc8mTx+at26IGIC/Rc5ycklOFkUqOyZuTBiHcRnxm3T0ojwGkT0C9H/LTYxth6TELhhBRBwUQgtv43Zs+RQurx6gvft/u7QTWy+7YHmwHov3XdRKT0L2fxHjhMGjJs1sPJSkqSC3Rhwc2eP6+rQ7e6Dm5A7OeMPILNokULjMMn+jRrnbRYR7GYP2c02FY+Fme+ZNGudT74rU7BdDyNi2KaGPCStcosgsa5gYii84FrtYjEjrfljH5MLIn3Iyoe40Mh9yEf6Weo+UKZ6yLCj6cizxXL5/9DoFbozN3ozGjzg6nM3bfQT1e+Fjs7pkZlbEVu55PUGdk7f3qh6deFCmCr+Zqevv75HBYFjXVm7yKJ4x6QCEnSsJDeJtpB83xFXxLErrkTL+4MGpkv5oA8QkWStfL9vdZ5NcSfHcu3tKzElN2ujtJURZjxNAqJdCRdiaQql6rPsso7RIMPQ2lR9wonW2J7cq86gfV798LCCFpCAI6E2FonxY5lgCnbT4110tJDZqXjmJrLER+SmiMNBcLE5IoWs9o7Ff0SlQYRX1nHce6OS6eMZ5WnLJ9EO27BkHdi8/8l4ff3ZqK6Bu69jhSf+eV+dkhFqOUQJ9iRbVbC/LsvVIBmUYaV7e1FON178hFydAbH/GQJbmg/g7Yg+lmHV6tlniQus8XJ0bcWxhcVcdRe1T8Pkzt33cZqXM/D7jTtfFoBBW+wsd14xnZ+qFaQuaPWAfRh6F4r6YjPAOn0R80wcLwbeWUwQpf/Pit0xtaQGPt+rkawXO3Fv8DKe5qTYG8krbLyDgrjr57DzVj5RihYFdOsp4WU/mtR/1cHNvndDywGjh6DPDRNHhcV24bfyRGxl1uAutp0o/Ha1+n9oWHzOfLl/vqRIkCKsC8weQnxy+JJeDAjE3lC0IIupbTIwP9HDq4QssyzmaH2kn2RrQw/c5//HGchsoWAbG9lwwXKMCv2671VfeE2fohwjNM7jL0bysZIQym2PoLQQvmwjy9nd57d8uTW7/4eJsFVgdGrECWw5OY7QFUYHyRLe7L2pEI2L1L3QTyuO+RXHyNDwFBDk/H+4WJ8ZnGgpYYM97fOnAbVkKvp9Ao6y65gIEcDDgYfHm4Hgbx6Vc0q3/mSTZ64CnSQctm9T1D7lejsIoQRzuuiLLf4DdubJ8cX2+a9QVqiw4K5HtscouIO74YBENN0elmq4G6Ll4t5WLYe0BeGdlI/wrj+OoC/6RInC+bLEnX7aiESyCmTFYrAt8eI9ocThZdwIv9UYkYe4exkhjPfD0854BI42kBX1PrvP53L0S18IyUg/yhqOQu2nE64nb9QKIjWPMqlxkDpT59k+KNeRCJu1UVW77TBJIkkLR31A5a9DzEMSsGN3PeEPYz3b3KTiUyPwIj8wdUyziL15pzHZ16+m/8GYzxw4mRCvfMikfG1Ku4ncDh5Dd9MvlcDDNg8wpsJa0i9BJTwsdpqMypr5PAGL8KFcFeYAnQI55QaG56iZRNYJFM2f53WYSCuJgr0+/xGygV7BxqLL6bl6h7YNX6ZuajHwMR6P8o/fHp0uDzuQo7XAOQCunKJr6FcUItT1u1a+HcqPy/ITQKrag23mzZI4xQLZvxOYyGvoo9Yh99unGDCgE7RjHl2SurZDgJ4Oc3fxFiBDUpCrWHxrLIpEns70qFq80x3cvp4g/b8UCoCm1d0gSa7xXTVgpz9bNzFeeIw8egxcdVq1Mdas1HqG5CNMUboweuZKYWcuNK0S4QypZJgYqntZ7Ur+RTGJVHM5Tc5TSp77bzV+1hGawxODs8QSRqgrRj/IaBTBuIRE/2ywknCsvj8rPOr7AJMLPIoZjCtDRNYDafd5HK+5c1am+7XX+G9yPNX6EVhs1x2s0U61tqYRKIU5ON66spo/otWHKmOhT7YXOhQXn9NcaMY4fTrzeR3Cc44S5ti0IhURKtIJWHCok/omJUHUAmhy93Qh+aW8dSDjB7peaa9WpPcaMOSmPyjyo16RwRA/26khtxUdr9GLP1FlqV4wHOmLGLPaNBNAOtC0Nx1OT4XTr1S0ms8OUUk1FDNfLnDrXGhWnxDsrlS7iv0aY6GNBSSShSq/wG4s+xwMNqR9d2+eKvZ94kmTLngoqzSoDtYL0zwBgKNGAlN2a5pR47PM9eiPzmU3rSfVTdHPsyXEvhoG1A/rCPRmOrND02ZNawL6fK4G6ExDDtVBMz/Q2YprH3d1l7NROC4ZuEg/jQkb1Oi8ILQ/vOpH2NLeXlbpE5kLBcQwRKBTm1Qq5SJvAGOAPuF9zY1NE5gSztVo745fa1+Q/K6VctLiGWsfYlMO7TNKvM30IdjfmRgzYLmzQzHrUTFQxyWlwRu3BeNV1xlqk9FpqjjSxZRYafLp8p0R/F/rBka7b/CxfOiNZ5x+g+BkkjQxbFMxRicJgYQtZWTHi6p9VcccoTyrwA2ueVBvLUQ/m589i5+fLlIpuBsA1qKF/RgFZMb6IhcSb4LHtqtkUn+UFbhDSqVvpwJ/LmIPR0w/31Gtkmsx+gn/EIzFr3QA+ifh2Wj+0my1gsFYwIffE9vesd1N9zc3B08JMzYYpWht/hHUpFXubg9ozmUNShxUNU6ECmDB+AcAYZF8kOReqAZF0dWPlJh+xcKoemt3diSfi4R+11cd5EveC/pqQzfXCgCb2J+mgPLEebcyAvc8/9lLLNtWEgm8upSwkepdNTWiBEZcfoLacwnEfHlKQ4TVdXK52u7Qdflznjni4ZfPz08Le8M/rkYolf2JrZQ3GsFfTpsRYhq3RHiv8Hrua3++i7HBPjLxEmHIQSBe5YMo5XboLtmpd5gXtHBfzgGeyTHjSmAd2jLlqaqEjdtVEfmJ+A08sGtjZjGZgnAwYemxDXrZQ8QB2s60kbeizj14aEcjGPrCEEY2piGFkXeOHnEc80UoJ55gjUvTM2EBP5QGXkZSsqiBHaLagTtBKY81G2ozjXS9Xp4kSYspD19nZ6lTCNlm+Bi5lwyOgq/hxVKmerxsprqhZPz8OzYogvRroXtj3vb6g6CJQm5Gtz9DOZHNL7HWKexo1zTF/Ck5gKz1lgDI265AKR9Bts9xvYocnk8SoX2bUAMNDBTgyzIWSreadfontI8WJIo22xHIuOYKsaJIqOZrSRExrkajTF0ZpoPB6ZP8RPnPlgNrbGRpP2+GX8XjSuSJb+1FTPiKU0EPNCAWTK9XujTdsh4YPD6TCDM1N5Lb5bvoySB9vvViHqyjyhG4igteeU7vGH9JiI2hPhLbW6JO8EcEIhZTQQxJZJOK3jIHCkx4BA9pIlk67ZAiytm1CoveHctKMHuXRn9lvzVy5GBARVgpvsF6CJbvsvV5j0gjYVDpaFYUgCqhC6kzJqmr4WLmS1iQc+cpYi4vnlArJ0eovAgYHaGgZpXszM1RokKEqjEnSAdnmZipiy5XOEpUFrrM6n98y3dkwV5vNPShpQfiO3ZHa+ut+PsIkjmi9E2/vZk76pgNPNM2qPAshywSoUHKRHDOaBI1JkY+DbrIqbQ/NXztcUZscpX34dNHii5gpWqJp4o1lUzPXBujQ34PzgbfDvW8jmvxAJ2IlAyY4urKCxfM91M5PdcpGTOG5mYp+SngLE460GsNIizZC+TbueMfcyvfh7bp0gtCoJP940fXXYFfQ45FOcmDc7clVqsnCulfp+HjB8yrkaQvLC8sNmkujq5jNJEm4LvpPEezdyv1WOferZ+QYyDbE/3TVKN0cGftQSlmd4N95fGfiLDOOukiVmlBUWV1puRumFveZABaoWP+X3+jx39OPFku3wapfS98kPSv+xWkMwoJz2qM3k9ifK2E3d19ZGVsfZk/4EfDQcIB64QsnDiQ+jR0Amx90qhZ5gC5qgIrE8e5qKzzrCcR8iyhQDnl6HDHHAIBYnsiAWt7gAn5x9sMdz8DaS0cRSCXHoy+2hfbNG9HKHcv06Ljpah17YCgqzPjD2bcW/JM5zclbu8FBjAvbtTDXwVuZCZ8Kg3QMu69G6r2brHXWeyj7jrXW3dAVb4jqEuyUGuSGjEAsIkAs3A9jBnyCUJkMHMjOQIjtqzAWZlrz24pBKu7R2Jj1Pjmt+HPNmdz0yQKb0vCOaJe4Y9cer8IBL13dXP0ObZ1i3i8/pzehcMLFzhLtCvQi6smCxlW8ph50RYvtskkiAEihM1cZvNU5aXlSSZUfVC6YzL3Mta9F2WR/97wk1sW0Xy1L4OAC2bkL8nlXoNK83sqlg0WwCtrOyx6f7XRYiqnK/Sg1/GmiTkKOFOW4cGjYxsbCQfl0iKjC0/cYkDLkobwpFtnkFz3OYMic3cfyXtynARa8nXm6Aa+DfKllXe+9pPnM8WAAhePB7Nx0YJojDopmpZdx7B0Oqe/hIsl0VbPTWrfPvKjTRMMkmB2ED0AjzlPHRhMJBNYsy5gWhNlIOHyGjVxcWhiDOrQGQnWf85GgfYzrgC5RPdb8u2xg99wW4x/ZewjvhT66uMg46woQiuJzpRodHpvPnXWyGHexN77UYsHzh2oiNZqZDzoA4eg8MoqLvfaEchrWkXsbN26rY40FeA7kYViykPF5y15gcMPcbkwyPpsYMDxjAccB5kwhoMUtAfN2y1xi1Zzc3codHtsrqaf02bqH0uWI6lWf8wuaQUs7U3GOIvVLZjvL84F5WVUxsccO35j20h5r5yVcUNwoxfbs/n+nqn4wiRmAnnilzIORmPZcDTrdPz1euV/O+EUCDrgC2DgY4FR4SIV8ptPajL+ZS79c3NiDCz+zsImCvHUCHIEZQljuLorBgRgKIm3WMFxaDfR9h4rSUs/czyN+Fj6rWFZ9Gj7JQ1gTFsx3ENthQeOJ3FDMeH6xiXq0G1VaWBKn/WyCYYYHoZn6XJ8inX9Vl9BDtgnNi2PblLYuNEzG+ugc4xVuzjl7gCXwHX1fO1MpCR4p5cqSZSjbAIpL4nKS0aCQo+9JJDBTB4iCqjTM1/nxz03DHmaklEyvVhEMtQ3yzGzdJs7IdgDyvF3uLYhlW8prlTwFUlWAW7sGFZ6+UXQpaarO0soKLL2EUh6+oH5O1KmJqSUTHBL7fWzPf7NZv87M9BYH2B3ZV7CHCg2aHmj5mTTzyq64kc23EqhUyasXSE4fFXXTB67pxHhCWT0frFw9MOKZ868+7bLYc+b7EIwnc0/aD1emUY6RnHsW7cZhpnbqF+3JXkzAGJogrrNHAUjszC0M1PZbPSrpedlkKqcXHwGoviiwKqN4gpJSUnAmsuEGHQkDQcV3hIBw+Y1RvLvtnKBFcf4MWVDg/ZVnaJk8yKCui6FQ7prTY03/LAlnfMgESFaX09M4pBnxXPlp3Icz+rrRUNLOeFQvEmjcCX3S6Uy0u5h6U7yDIjPK3ev0SgG+q3uMfsJWvU76iB4RmS5JeJLwuNU2PeeB47c5y6lZlfqveXIIC7dfuVEByA0nx+E2OxGgkQLbDXR/FQXNImju6jxRc/S7nMu3Oxd8oSSrAkhfMvBNB567P1qdfLkEs4xY9A3NInQN28WnQIzgluuZehy4hlAM2MDXJQaa20rVpewnm9iJON1Q3YvIWo6lfeA/14Mg6dM09J7fE4vup8a0BzNzULAvH81t9ZJBxZ0xE+JnSS6kIY++BbTedSvu0pQMwGWJHY7LKyT/9oTlW5+7otlyNPqv96cfOudnqrhDC8ym7QacfDsqtEQPi1NwIjSKpFNhMVfv18epg7tNmMTsZ0VPH0F4gaNSfsAjqmzVK8m0mHHuJ3vK3aLLcDIhwK7AmIvDFLoDQ7iMhunADp72F3QAv1sinLFUlyQ+ityqYNBGIkIqGayHTCmxzdzY2Ep7dcxq+FIbYHV6QSp5zsCdywSlbNbx5WdCLcYSUT/2yjTeuV+rSgAnybxOqRLS3GxJ+lwkOjQPoLwqT4duQM8XDjVbvt6ih3NCprZ8FEaDJ8+x8ypEyHEVjLulFbuzaEAxVK8pFCuaI52/s01uaMZ7QtkA1A13EoFNHP31Bl5h1i4SxUJ4ZeRx8FsAOPlTbBaF6xIedARr7+J8FsodeZd9zrEjMbnfjTA1XtzLoGBlSwWNrlwYhmtE48+3NIe6wKpGsaQrn5MhFiu+5BgyO3jn7niFRIVPEfLRhjaDRVvgXrSlI3RT6ezzJUvr/fC81HEps+5+sPBmcY1tBxfdFJgC2l3aV/Me/VXax3s41xeZuEwWJW3N8isfx1Fd0qX1rGQ1lIJhCvLpHdLu4eCKzkqhMJUamzHD1BqMOYR5hDAm51a6iybpebLwr2izbUV2TdHEXGZiJsW2iAdiA14g6/69XVSwTMgdBVTzf+VnzKWZQoyKiZQdeV5TtocnoBPgf8XjF2f9zX7FpAVmwzqTA9PHjCJH9dFPB0+VSbGx5aal7t5eNLVOY5JnuARL/aXRS7SnjVMshnK3m1ZzhG4eWMWuMA7it6Y56suf5fpz8Mgmbt6b1c7G9hBryyHSSqsXfd9PlFnWxZwFo19z50nKFM63X7VdFWaCbhrRYQMYpzf2kxUiT7tluEplWjMLphUbQvN/u8+llSrgEzVe/xY6zgHbQ1nQo/zkdAxTRswiwbQ4nuUpHBXkslYxBxcVqc3NqZMPfOXcF5qoW/5OmKj9OKSuaKQTPxL8uwDrYBLGvpFRcCSeHZw7Fhcg0OEDG6DPZT0VXgC+URRExdondFKiRN/Eqo/pzTKDUSCbWxrAdk2kUlX2yJinNesRdbbO6GreZxSv5JDPQh7leqyTV4DDygyggPxOPR8AnySH7/FW5khievqmPxv6VCVlLch8kZ8+pxY0WtyCqkxk8dPr+er4aimtdbKLWsUUY2nZ5N2rGRqEl1NJxYctUOz4WjeffMaX3kVdTmIJxMLKZCYaPzQazq0IcR8hBhDJwg1mR8IGhGCwQZghw8w4+onZcUV3KNx3h8gG28fGhsGxlD6ul66ybWKa20hRCxzQwbTcZb0h1m95mjQdT0JIqjY/8iqDMTOW+69NruR1blBbkY9ZtZy0KtJfGYgiR98q5l9NJPTHJN38UjgeHcY1v/HUpNO8p5GIlGDDHKtUoQjMa1a29FAiCPVKI87UjICl++mqIGwrq2nP5x4JTj/G1ELVUz6cDfmGxGWqThyWjFmK+/zYtyQsyGrCrrmLQB85SbO+/uxdouywUer/+CjWrsQy86J5QYp4zm6Yq+HP9yG+kD/33Nnf45qEwqIoTNPk5rBHvrFwNzu3yXpw71H61Rc3zFinRT52wkdwUoV2SD+8TgeqIawfXikyiSBeJyhzDhqZwG7QIuk0HwqRYYI9ic/PA6pHO1GDNQzB+q9UsAbAcrNEQny2VQ0efrYnVqi/klh67t7tvCBVL4M5BE1l2+tkb2g7K3Tx0vYAu0VkvMRyPzb2hwsc3Bz6XmdNpe6+mJ6cfrkZaj9CWP+QtHht9pqsDnuw0ZzP5kpr67+Ly49mDVi/cCw+sad4o/5XeOMujUQyTNjvsGDezWjcjFJyTmvxDL27g5u3+06obqYOCQS6x3/bNy5S4FksRlu6WJAnAPlcjNRm2w8lBcKntTztwomPGWzSFNrQQyaLvW+EgaYB/5Du2e71rXYTWcCSBybM0JSCe8sZBLkkoo9BT0LNdDyG3UXR99CuDfEFhlS8GbEuXP403mAPgol6AQToe5zmEZD1FKj75CNYYifOcW7as/wA8QnxBQbIeILXKqFd/F2bwucf91WcnLmpLleo6gTAsdEvS32fGU1wZvYUIRf2pa773iAbrii7tScT7yOwNkgioMW6P0K6S8CIaigi854fJXaGnLBIWH5Us42+WwyuzAB5LxgsqwZyesCQEh4xtcbbnVdPI0iJke4uxC3i96O/z8OWwIFC7AzqTQhSxVI4UyVqVhzzGCd80SK4xYWrcfxGWNR8/6ygGu1NOFKzPaquOYPEmrm4t1EtfQuF5GfJ5EMXRtrxGiFKRlKhZRyuBiNq5pA/0Qy2+5SXLXxugiMZZ6aYgw5Vw67aaYqZgF32LTF8GHw0Y3Ci4lC9s7aYQgjyo4Xu7LBFMOMU5hjYjH5vkdGpI4qL01RwXksmc6EbFgaB662ZyXxREn09qHrV5CgWZ/oQ0uSeQefn9QX/etfqWrZf9PL5ugNWCP4biUKurzOnOdSi4T/0TZyVZLsR+aqepUGZx2R8MBXdDk67B8riGDsUAN/cSz2bVi7jvwn0nK2JL1XJllInFsLBaK3zRE2YhYQpJOeVgMJcfwTYmI8NAZ+hwvip8y+h4GRpVaULGYINxKLNpVkqShARF2auiJmMAIs2jfqChpvDvUSpy7zThWoWJx+RjOYPj7t6bHBTQlyPiwej0rHLB9YbvrZjbukDlEGc3xRdA3N/mWSVdEm2acbe/XE1OldPZy6NwLhherW3s3ZH3DO76oHDUTm5tH9bE9YDL1dW+BjyByJD2u0Y3uBUFi/fsYLE4d5thDrDFmnAVbz695SETaPGPDLmIGGLoOlC8yypVKHn1u/nrLngzNGmPUti8J3ITqEzzWcbjI/cDHsG5mfHWqhqosltUKO1/5mxQgHRBh4rA4sGQDNcvMThzY/DXLHVHjGkzhQd1KB5TJo558FG2Pi8RTJxtzO5kPy2ZFF08awgkgjd7EGw7mR0e9DVTnm/aM5PplNW64fsT4RToWbplxYELDQgojVJgxbcxdVK/iaFcHGiKfi05lI4c/kG7n6v5uUGi0r+hkliGQlK0W7Spt6tNYxUf4X7Wr4MF4cNzXmSQ7AfJnZQzIozPp2vUOrQ7EKgytVUsA5bxjedjBFQT0++gmsi0BH3IuNguB72dM9T5Sk64hNAXLnaZusFfRXgJ89Rque4i23reRZuPpMVKCjcTi8VtzzpMz1FM5ugBMWRl3nz2bI73lQAFEHccRophaYmZzZn2VXIL9esr9eiMOXoxgIwT6t3kP1NJZ37Q8T2SC2hvbOoRgIo/3WT0cT82nRX1hiICzb/tts0KS3cxRfPSrPq77DDGgpAJ4s/nIhltjjIsy5/P+LGcENvxdoWPI8/8L8x8HsgqsRangqADj1hMOYXCyDd+LUTeCVSmlP64Ke2T8NieAZXrn2qcUjhk/yc2R6EHZOqmFd3Axe9OdLdk5mufVRKAsgFlEmGG+wC44jcwU5KhVfCLrIoPS2O/hXD6Hp8UY3QWnz/51/UjoE6xsCICbz2/hoVXXxulFzocHbef3+oBeOVGBCshFaALYjsIDTjkUR1/J/WlKiLEf/Yko8gG/LqjuEUnyzLu5WOrJ4/91NwPmKYZAWBn0u/Nzyqh8/wAwZ4zmLlT4rpK4jLv1HiqqKe4WY3sQMXjYgDf8qsa7bVkM6AK0hDiSVFJZd+iADgCZw487jpPr+IPtVHAiNlvn07Sfj6EmZNsjfDD9uFI3ZfcaQ+cC+n5iSmF6xhyNJvG3O5a1ZvUwlgu6kGL3YnRc14q1q5RBvS8ua4FWYQ/7TJ1wUwzs9qS9CgQ3ldigjp0GBr4aJfAte5YSXoe/2sS1BbvN7fnnYgoHzAWO5ViygIAE82k/DkUbHoPTgiatlFMBymCM+MQxQH1aWW5N9QKa3VaZBy9UhwGb8/8q4WHS0RXZIRqSTQF4ktxBG/O8ZqYrIIfGTD0Od6OJdezNX2AV3aE70OVwnXYherb4YWBC1quWgXS76z0AxaWljtOEX4gOl6fcv6XgyUOfhQ4aRqJfgtExYNy1zcnCxh/FfBPaBvxSpJKUFBHz2h1HvvkbLZvMrzlUwVO6HwbGdyOjbody8AfAUGDc1CL0scBeN6FX8GlCsaDnbH0N80mZ9d5U977CAKMoOuNLXuhiZi08M8yXUr5YAthh0li6jzshG6iHjk+Pgd6cSp5i91H/NmupOn7DTXXYHp4adt9O+ZBMMXPyjo8h2kMXlZnguUI8gTJXKi1G7EYMDVF8DL+NTQXEbvDn5ekWAmQqfWHG4KJGmDQ/Zasr6++85NQQNT36cSM86CpCJTc6Mo/o+xyr1e0nJlZnlHhXSVKoDEyr4l/YYPaf89nOPJAWhn0+O/H08h6YCsKzGhVK7pJ3TWYN3XrrVHwW+1bF38IdWvWiyAFVmhPCIsF2+0AQTbbT61J3RKsnIBYgOMWByhn8Og2dwCQsatVlm2Q81KMEb2tjv+Z3jRq8/Z/lW+dK9bHK9+14xmvsptyQFTtlXOHPq3bwsjBMl4L8Y9rcZEP5q+ePI5F5KhCSUDAjxP8QERJU+l0pIkabbuueVCGJSp9mv9Xd0Bbxm/63Hyncz76/NLWePS9tfQDWzyx5iqDlwP6y+jz/LHg2Za0mzEbsfSRKgW3ouQlHSecf1W+Q9lB91g6RngjI6drwS5DtdtLy3iIT6w11nee4h+Sg+x4xzfx2PwdycbG35lFp2+BqgxjrQamArnRPrmM9Fn3/FEItww0IV/fM0tPORXVTqtzS9dhzVqcghsr04pYMq8AVAROkkU1qikv/Fi31CF7ZykAAcIBJusHPm1vyFQipSJTnWF5wYZKy6ZGvTbv+NvxxneoU092dBewhx8+s+uU9U9Z9REYGiC0mPYivs3znig2NoWWqgY8pIbpI9JWm3WZD6xE5FrxHFq2EtmfEluvlrEM50FSzKbBIT7Wo4O+fHiZHMY+lDPdTrLAn7n/ew5DYYhr+2ZeRfvbn2i+HovtFQKtcGFV+DWmvGicVutuzsnRuW/0lrw8Gt0gd+/PON+benq0+mo1iXCPuWdxcjOQ1dYafixDLXQRzNEUaig+Ju+YvoHadBL4QeDrEzqIY3qJ9sgUdYRAeakVH/AU8B5laM7QaMlNS1hmLSO655n2otaEbiF7tcZm6K9Ai5ksO5PP/dvXOGfwHLEz0XX5hQ+qJ7UYisKhGfzftqh+VHYzCvzCdauGrtBvwTy7ojLp/QeynNgvZ7R+aYmVu+uDuQhNG6qw4wsl00MPESDGkIeUXrN6Mc9hWflJLLvwX0XpgvYb88WPsSdJ1w1G9978OThEAdMW+9WPmrt9B3RQG9iuXhxWq3QmJ+NkB+qno0m1IJdl43r2ulZy47eDtCsYcVeNgNWYvwidVn+GuYYZT/382g5OLqAabX+THXnTTszIWEUw0ibgDMVI2eRAcC1tRsVRz0BVGq5hBStAWMwRtecbgO2z3hoQdOqNrIE/dUEM3pinUeZW3JR5sn20r6zsIThbRcxDe2uzb+bqRs8ApKLsqLFW7nw8uMbIno9KhUKSK2G33ZWUs90L3a4h1BnEhy0287HWxNsa5fp2bTtcNIZt7zj7eqs/GVWecpWK6Wi/Ab3mAMaYNf7s1flETCTGJR/9CqIcNA57cpryUYzsfAgbciuEO8JNaUZQGO1jOgi3Z39X6gY6ZVr59lSzACOowz8kG52cKIcl/q8PK0EIB7m/dQQRG+aP9d4+ceLq7r682nlAaybaQ9OwvYT0a/PTcsp096uCSevXAeiNZWYRsDaGhnd2eIaUlNF1rYiLdiWrpnczmMY/zMvnLf/mqLmTrct+K6DTTEOJ/akgEsGEijsjJVAArnwouZa8BCWLjvdK69DG4laJH5Cdh/Ey+zLdF1wHoFjBMReFOFHrW3Mp1Nm9IQfwM5k+Xk+ZwXNIhTdclYghdhuq3mLCdGRN6YL65PkqWhSM+2NNcjEXSySW6GdCXXNQ2dSxcHaUhhZECMkXhSCa6ao9i9mYqTeAHTjYJlc+HOW5rvh+QzWfFoaG/cOQKlnGlzUqJMQr17OOd6uT5rwrImqvtDoWQYC16KdUa3//Z</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>9</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Iris</Type>
            <Subtype>Left</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>100</Score>
            </Quality>
        </BDBInfo>
		<BDB>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</BDB>
    </BIR>
</BIR>
 \ No newline at end of file +BioValueWithoutFace=<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<BIR xmlns="http://standards.iso.org/iso-iec/19785/-3/ed-2/">
    <BIRInfo>
        <Integrity>false</Integrity>
    </BIRInfo>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.670Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left RingFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left MiddleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left IndexFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>60</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left LittleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>68</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right IndexFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>72</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right RingFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>64</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right MiddleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>78</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right LittleFinger</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>47</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Left Thumb</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>79</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>7</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Finger</Type>
            <Subtype>Right Thumb</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>69</Score>
            </Quality>
        </BDBInfo>
        <BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>9</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Iris</Type>
            <Subtype>Right</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>100</Score>
            </Quality>
        </BDBInfo>
		<BDB>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</BDB>
    </BIR>
    <BIR>
        <Version>
            <Major>1</Major>
            <Minor>1</Minor>
        </Version>
        <CBEFFVersion>
            <Major>1</Major>
            <Minor>1</Minor>
        </CBEFFVersion>
        <BIRInfo>
            <Integrity>false</Integrity>
        </BIRInfo>
        <BDBInfo>
            <Format>
                <Organization>Mosip</Organization>
                <Type>9</Type>
            </Format>
            <CreationDate>2020-01-07T02:38:52.671Z</CreationDate>
            <Type>Iris</Type>
            <Subtype>Left</Subtype>
            <Level>Raw</Level>
            <Purpose>Enroll</Purpose>
            <Quality>
                <Algorithm>
                    <Organization>HMAC</Organization>
                    <Type>SHA-256</Type>
                </Algorithm>
                <Score>100</Score>
            </Quality>
        </BDBInfo>
		<BDB>SUlSADAyMAAAANiLAAEAAQAA2HsH5gwWDiYWA+IBc18wBgFgAAAAAAABAgMKQAGhATkIAAD/////AAAAAAAAAAAAAAAAAADYQgAAAAxqUCAgDQqHCgAAABRmdHlwanAyIAAAAABqcDIgAAAALWpwMmgAAAAWaWhkcgAAATkAAAGhAAEHBwAAAAAAD2NvbHIBAAAAAAARAAAAAGpwMmP/T/9RACkAAAAAAaEAAAE5AAAAAAAAAAAAAAGhAAABOQAAAAAAAAAAAAEHAQH/ZAAjAAFDcmVhdG9yOiBKYXNQZXIgVmVyc2lvbiAxLjkwMC4x/1IADAAAAAEABQQEAAH/XAATQEBISFBISFBISFBISFBISFD/kAAKAAAAANd2AAH/k999HGESLC0b/ZYZYqV3nQVxMAWmzXxqDUhe4XYh97WDHH+hGdLWg4lb4zUkJR10Y+R63i0RzyupW97EWotG6tiS/S7BPMoj0AJYZQS428u9VRhvBGCzxu21YXTbzjqjsqXiHhAypcE92D4kRliwqnIq63ix9OU4a52nH5Q3TvJmuPbOALi12KSuqMMyFdyjlb/H2N8fY7w+xuBtE4G/enTozX6wmyJUAJYm5fzHNNpDfI7d5j94PzHByyAjC0oD+CxxmExp/wb0CQZKL8Vb2vr6XWxDfhpxfzX+BA1XTxbAf1sw+o9qdXGAVJJD0pCqjJZR+8WWOlbgYIdsnMcI/2he0y6p5HsUWdoHTuLocUybQA5E5YBkjioUqGrBPVJfp5hDGNGuSPkU4g7vVVkBD2X0AjseOHaac0MBDtumHhm5LJfv5vTfmR37PDPFCt9UwFP5vTbaBSOpohQh8JpiFiOJmZANz/mnHZ1ABvcodnP+GkJw4a6HD77Nh2fJOSFCJ0+7Y+FLhnVwCAA7IijpY0X6VaxNxt1nlrYbfib3J0I1MnKAidXMA0ZzjA4suSFdox87zP4BjEP7ClFVwe9Kz6ssH67vJFvO5gkACtJAwS8/pvRZRAJ9BPX8WlYlMSgVLSsfUYNX48qMZA86muo/x9mtEfZsZD7Ncq2+kXtTYBu62kD8z3SsWE7/fOR0/35RcAQ0JTUYqGI0MyhgpyO7lanRcqpiELKSkjm+/x3YGy1EztkpCOAK4fz1RNMaXujhNWar5lolFIt1E/CuFkmJO3r1Ike8cP9QWoReOb58rdBvIEFAVOog9VXl4s4OrOpI+O7SKMOG6LdbqP0foVXO84mQCfQLotw+b70iI2JmvqCOEmxhntvW7YO/Dee9JOmqLWJ2U1rkIYth+WnB4fvarVJeJcn/RECNke82gYHTfTVrgim42OeA6QQOyGfammokrkrki1PVb2gJbLXtN395eY47zMs1NMRY6LnXCy4C5XVXN49oSAEZVNOMkvZnGFcBMAQd+K9sXWVWbM9ft0kMYrYdvMEwjLZjo3pOpgVfZEh8bINuncCe+C9jCB7O+rORyEJLsh5QiU//K8QlgebkuhF4fIRkXpgmwkIvs1PdyX0Y4xFABMjo09t7obD5LIXTBTa+HevAIegQyimeb+JTV8xCIGbyUuom38AlArWZCKN+hZO2DJ9ase1eFpY8zyTN2tQ2BalJiOK+rfgOVP8A8/LjnGq6bjF/LHSNXDwdp5E/TCTOmZ51p4tEtHRpi6hARkWv5DsHYslTKvOwtost6IeQ3g6x+UrKIp5YfOnRtDcioEP4r/2vEKLiyE1BvNglQvloNAIxrUciWH8PVF8ZeoXGlHahHprVhIYoO4IlURgDAVL3yf5A3IclZzahKDbvk5zb8bYiWHFxHX0qlLaidf0766ooUpEnu7Bx1DImeM7tLgSTlr48FMcvbNXWVIxZ4GIpMb9wyJfyTK5xYyM3SrEzJujK7j8j12i5orGmmp0/vMud46csLmrBBQFUtbMR8h0yxftmfPT4i7AQmpHSkfzks+VtRGvC0mb/Lr1v03Esul+HBOs0tH8J6/ZhMCJ8dazBoHzexZoqhsYqjaKbs8ItRCx5uREZW1r6ngVya4mjBS6GQ6bdgISyQswtBRKEGRd2hGN79bYJTiOsVCizobwmBHaNFZkRkFtdnYwa+/X9TQCPEyraKVwbcAnMfVQTviC35jZdWHS5vIGugZEXIBwN2Jma57Jh7vxWMBy3L1H5l7mj/22MfB18vat2pfBvMxc5taRxLhd8Drgkg5yeUGttqxmxRKjHEEf3JcTExs374s/uS+wTy7fA/v1pxAOgR8zazoBuyv2yPdeUeaPnYZpNI5RUAzgXJmcTKbdZ7y224lp1cW86W/tG4SJhdVagROokkgVd35MXadAmI0MK6xHXJsPVI4fyVDLM30DNFCtBcRAe58ZX38tpq9S0+TrkZkuEUG+mfHXDkPZS6/YFyv7sU1ZRZkm8q3pYcP5+cIlYkUs/oEut/3uKhpKGMcnUoLm0Qp+u/lWN4HbHgfpPVzbCfG3hCbf1dqhfpgNY09jtIqmdMQLM4/6BPUw7ZZNZVNKC/H7E46BZLqnImN/Ha8GMhsigul2x0nhnG64Z9G73LaNzQHdFzmdXoKRq9T/Pw9L2Pt9PuH2enmB7XJOdb/fsilZiuLZviV0QG33B7u77A37aU8goYBIs3kJPDr865K+xm2blvIE74c20gU3eSuAXL39kajASVyqLsvM/3bWKZf0YetVoAFDCquomvdvYEJfCbuTkwuPxc2lOZ2qwN6fmqegV3p7+NenirPhutzhzH8BvPEvvc+jMr9Jt2BVTkpl3852DbpA/OlBELOHvsCd0YTTA1YnR/3pMZGarsb35YkRoOODRfB35tLPSFTNoeBvDu4muuxEuD8hPBEauyWp6MaFU2yE2rcvvGxxYwftFm7dFrXp08iEl9xuplZHFL49d3dneq1w440EYbUCnWH+WU7e7YQSovRclwljMmNH8dXLkcF8DLVmbjx9cuHLFf66MkNMeVxr/UHUwvkmvLkun0gqwybXBqytddA7vuUx2FLzOi+dHF+au9SJBX9aNShUYarfohfDC4V99Krw+urIm6jW3uG+zdfABWYuZtMEpv+9BGE12SK1g+cnpQWFTtvIlnr+4/OAFMdIcrvyxrwbCN9C1uRWt2ZyvaqZIaUzQqMhFNXdv+7wnn20Dhmck68U6Yg/BJLG3F0orZHexAwo4wL8mNHhLu+ro9Ue361CctNezDUNUlX3vtb5bu+7AtVsKfEo+4pmpc8k3oEX6T7lb44LyN4r63vBAJpKimB3NwGq56sPbJtzZuhHkm0C4QQtV7mj0oGMoHgWr28kHNof41UnQLQlIL4Kqq/1f+wbgk/Zk/s6zw1YvUcO2+JphgXAsQ59b3+rw7TZXXlo0HoDXkrrbtOLsmpUGrwJ7iW6S5cwKQDDdinh1pQPlCpFAf071DISqvE1wZRaxdAbEaPTz5Yq70ZpwyEXPN6h68rzRfpD4ONrlDJjWqRUTv+0nIA2b63Bc6ObUEeFRKTRh5Ekv58TkHc/yvYQJ2IPDfBKXUVojvNTVOY4Dt0vaZ/6wDKBO4uG4sfE1oTxXr7pmy+EQbWz8v6MKwdPKCLeuD9MvuCUmitdoUnED2IBNZJW7jM88bLP5m0xUuz655mAka1xQLNBKQNYDXcBl0I9pNzMRoa0F6FvGGoXbhoNWkO1kmrMm0oeUrzLw0PEbpSD9LHz5gtMfgO0X4lE1xry0mANhZ/Axc8LEruHTDJy5J8vat7W/892/xj+0WmhL146XF4dmFPohtW4UNex5StmWqmGU4g4az4Q50n9c/FPFpszJ+iSJi4JGS9tAy+OGDgn/ISCusywQd4OI3CDutVdGggoflMKvcclvjWeQVVhrmxSgSqj0T7OTlvwoPA/QumPAotAL189cbwdxvMHKe9aXZ33kxFHSQIhuWaykGxtt0dj/VXOSixNDUCwA+QoSaoJyYpKKgMLH0EGyV7O3o+CibqFvDLlMazUGYwqHAdC9YRTmxA7KDHMtTFx2W5qw7oIJLPIo6ewO2xYCJRXUnw5/t7OxvqegVOcrVH/vl5ZTs7bCEOiw24DL+ajPREjTGwQqrJXPHEjQVHs/5nwibG1+sHVznBa3IoJMRvToqON5srCInQUu610UMLuRNTbLjo4S08R+9FVqgg6cCVCA01+/jYCO83fBPVMldLpNPfSntS8q9Wml0gExclbHtGpNw6iICTzhRUEy1Wxke8n7Aj2CnJA7VBErONT8Pq4lLz+tx/5pvfJqQ9+QWOpAAEYeGbbJS0ZDqh74ZP9wN19F2ctd67p87o0Kf+sc2O14Oxphi5nr4CDz2iR0/wjFYITwzzzC3GDod03TESQyjGonFaBXxWOqVMWrMuO/D3NbJzjHxRByKryykYKMV2xpH+Ppn/t8rLkIXHBlKi5BxSEvHt3ywsmCOZ/q8sa6MiYx8+YGndBINfUKP7ybRbJuSiBL5SO9ThnNWma4o0TzS36Lj3OXImpvRAQm51gIzvRioAB0SO2HLinxQQKSksuqs3R0jOlYlmgwrABivzwjC82Cc46hm55jb9wAwBcxTzGBQgJXmw9AmfnVcKOS11EwBtXWElAVkGCBZNmIUzsNEDRZ4hOqfMYjlCcKlLpyiYzQeIS9X2Ec3WDncD6Sn39Q9p3CNkIHX6CD/Dpe4it7MbMXX/jUSzd0NHRrfTH1MGYBs3UwrI/Ii+sF4hH3KlJj4ly9sMZf9HGpeL76EgDavPUKQnjHwxWq8eME4o08Y/NgNqFuzjldsNgClMHqEVaBqkLeS+5Qx+R22VJpUA2ILh6j3KNxdJyB8u0ZlvCWPl7mTXrKPaBef4h5OnXP7IjghoKftrE0z6IASMoB8fBTvOxWZh8PE6MiPXQKpsCzb4WUwcJV2pSCxzeisyYRaMsmabZI+h+XU1M0WcgyjcKtNHcmamJ7L0zZSj+toss57wLWTspFR3/xfciCppQgwbg6w55sEMD23p/ynEsIS5al7ewDnehNHZybPBR6QqzkoubMftKu+1Oybq73khsn89GOFomnWBHlb4ZPXX5zdpnovim0X3kcsZfmmq09TNdxRbpBcKFbN1cQTHSF33xKx4udvzU0mC4Q63BOL9QH5yzUGUGqR9Wa29rrHJchCcKuLWrYnlvI72gfXB5w+c0DzV71474BT6rHrkayHp5iqRqDZakuTUYUndqL9xZstUYKMrJzUKqlfKLSViq+8GA9K54qbXLDyAemX0hMjDlnnjAtEta/RIdYtR6ug/mySnj8GwQ3GKeIk1UKnznpSpM46qzQvNcHKTfCWLA1SC6Af60QtICmpgQQB3w2GO1Ph0/BGg1o05pw5K2rhqPh18jj6XsFGARnt/dYNzD4Q8NDJDeul48oEECpusygkbIagJ97eZ4/F8Clmowk3Z7MsCSOEWqnTVlq2yCb/2DNXj20X9wKfaGpbdnjayTBRX/psRyFjIvwhyirpRJvSIWnCO6Xq6DPPlURPmoRmmm9ivyWCBHvSbeYg/4W34cwbY0jNDPzNYuQd5XbeEbvfQNa15poA3oMXwtWQFf2a0WoXvsfGIkglHqN84FjwCV3lWkwaPDiThSm8wKKVDtwx5gw8wC3hoif55mOWaSP21l6iGpgb3PhURB1i4wcTe6lFKOWTrhEEfDEUMOZm19c2CjpIa/gRY/YRIRnGtaC2cC1pLBqNsYXjENCYrtnf4vHcimhHcExK7ShkdTuBkszLSXBrE+pQCTqqpT0GH2pgWgWk5TE+g/lMVXzT0tX5n5YORkqe0ej29U7/AeFaDk4284dOUECGwrYwKUs01zyfEkr6ge7h9f6VOIoAof64er/P4d7M3gL5EHQDTEQ39w/CZXqouJoRDelbWs5ilAxsc3X7fRtliDbCH0vEltXx5zeiepkro9UMs8r1n4Zhp/G5RWfQahboF46yjw1xh4dmQY6/kWeOZ5ntJhvA/l+Eh25Z+K5GARyH9QI5LaiyqL+mUbTVQinW5T668cDPNMYJmEB1CfS9Fcp0bRTnEdCuT5ETnvGVDLjoWLgYd8pZpmA3BX+SkXSwwBsVKdXQjZcSvDCiR/Ereirkq3DAo0NKw6Qgz/UNuOoQP7d3NDfMUB9S5aGQj1DXCtJgW1ngsYmv7/ew7aMt/2TmTAvp0NYLCW5SLyVdVhAnmvVpG0HtKOeayNVkH3689OJjsQKOB7AAyNvNoBgbShidiFtosp3GMey4Adcx0XP6rcTAqpywliW3f6c3vfqxdfuwSPnbsNhL9hjZtzl3FWfaLI2m7ogerTGk8e+5681KqBGp9OIDMe2EKL8gSTGwmWbBf9gzCB72oZpmzPx6W6u0DNqKkUcf5mpLlUybKtJduLIsJK3vosX3MnLF10B8PYyWj3gbFeS7TL6zrNe+/LvXv7AkhTXWeJCtJmaPut0hKxKBrGWLNJb5WqtSwjUgryVx251TION9BfoNijfvLpfZy2x6szRXcZ1fT9KBad+f6xeM3hSGADeAOWU0ua3fQ8d1fMFDJ9Wx9wxX7SXFdO54DlzbcWDX0CvXOf29xd4ww4gevYAvEpUC5Lq54k4/yymS1Vb1KkTW7cWe2dZFtgYKPT/HSjmRS/BGTVktjzla7WP49u80a50ngNGnPW4LZaeMNVO8kKttb78Hlqi6Ee8CNZ1PdgKA3JX+6N00ayUOVAwejZgCgQdJisGgAJpnK/ZVEkVWhU4GqQ8obXa+hFfQOd++EXTnkynsQUDmW1tNArUGodMFXl05ijFEfhwbPXcq8VvYKRnFbK2p1hoUvJLOa1DFrg7UFcjS9hvIgdiSrNUgjOPlordhBEt95h1em4HTpppB3JhmZC0Nr/4odq7ql1Bpr0HYvaOdgXdOEhy3dkhPZK1Xc60zD1jBhe7Y/86/LO1oKhzl9KaLs7vynmiepfLHb5CuruTKaKfky/Z91yQ3p2Ng3cSyTkeNVPrPntY0MaegJry9EvOer0qJKatmACg8uiZ5WR4gZkNBE2xkrGO16nK7HcatPyHgDVCi1OshA8WB4a7JJipK9HXJyYIpy1q0NlML4/ApgERBBx5VbEOTjLCeUOmeCWOOk9v2ESf+UkqM73Bs3AictqrdwySgUWq3uqpbTfgbiEOA24RwZQ9aNYqNFY8fhtWj4L8c5isQA/StDmm6vYuC3WW6qL+KDHaV5rgau3xVPa5eiY9nFnYS9iGPk0yr7TWCeAiCIyUJ0eNcW3DvxhWAr+lXQ36pPCaX4JnZ3SCm2zHJk1nfNnblGXXOL2c5olKabooHT3bj3gc6jco6CMcXtAISl4W9HXwOo22quwZcuxeJc8CasMBg3sL2qpynsvDzG1OFcflBGb8RU4iqJbDE+ZODidp55H0OOoFyBOiFB0x98+h+Ac5wLS8R2X7s2lseRh3xh+1TTP2V8OnXyjpy08REiKzej9U8VvJwIOcBY5EDLF5KZWPk9/lPGaYAXmo0XzhVP9tvGZq4H+v0dxceW+df2H6UA5avTk8V+FEl0zJhx4CWPQK5IiAFGR52WuTJvxyiMFJzDOYrA2cBwWUMuARKiQe47XAtB220230y80Rk7e0DDhNHmlWqiZzhO1I2UeT81UxJd3GtHrMkWryeEHc0+P2fR3X0/VJnz9W4+TXuP2/SRfs9dP9uvl9VmYft+kL/Z650+frlfVYAMaodlEniW/4qAnLSHthVh9jVPCXmEQFiFMMZqf4C56fe/4ZBDK45TWfw5LU3vR5IhrPCL8DcFyfeZuMpHUsaQ2AhitUmYe5V/5rysCoawC8E6eDY0YtFhjOZVQA90P4LdnebVxYpfb17cdREn7zgk+4q2TBreohaUf4GDXBtYxJsiDBtBuqQwCZ8M+uEYuHbsQt9xWXuip4cHTY/AUM0YkfXr4iplniIJMJzwwYkH0WU98DYa98RiKq67h1JgUIZQjQEMwQFim21KUsHoujteAv387Zg8UOSCzKx0r6D8NqwoxUWnQnlaMa3T2NiAyxGrQi2twZInqShhVosEewRio+xypWa/3Cs/AbVh9/+/yg7FogbXE2bk61Jfp39Uco1b1tVue/7BgGeyeWghYlXgJKJN1s0L4BG7xXOEq+9xgcK/p2PweqhI0norJdhQTu4CUblA+fH0JTVSgiuFyQuDddCRLDgBuWIqit4ocQ7tq5lgAurJt22R7POVD3CgQnA/damCTzFwXdGDojEf8ZytXMnPKA6eWtJrNUEX6o9DjnU75MKh+oBwZLNAIDCZFCm/hbjgH2kNKFUvLb+XOimeYO4QqSbW3YuPqoFbjbwpcj20sXcfq056LzkyGPegT3Sl8BH8dGR2mqdZWiJaOh+jRB528iIitTJdNXcFKcpZ4dzJWckqjNWZMYyQbg+/yIV/nsopXH1lOQCp+5Z87j7F133A4aVG+i/Yee0JwPeWmUamLtIgJkIbTJoLXhiPNoUQZuLOejEpzy6SegpYg9y8FgHnh+v/bJVo1je/3fxQwDmTLHbHvSikPYPfSBzqVE7oc4spjDLey6rkV8oaBlxDNMD8OfFH9nKVsitarNK4+s9A5TFioYvgqwcSyLkn1tIISOK+MvZhSt3OTNqvbJErNZ3suaZzCBf2JSGBmu5t/JluJ/6nzPRjFv8iISpB5gjVFtpkDPkeF1I3OBw+Tcn6PGmATrSqpM7RFg0X9CFj9Ar8dO3q1YNd02nRAFTuM8TrSb9rs6TTwOg/mHMMyqT2uY32kTyqa1N1+Gfn4qapPbQIgMvY5WZHtbws8yZsKxyKQ/bbb2gp5ePli5eILe8DsPQsAuiYA82UMbzKtMVYe98qOa/yNmGSpTVauMm023R1GzuyMX5Der6gC1Cq2KYdFrJ6gn/RtCOCwFkw7APrliWm6T4AYVxMJrqsguTjb1Jjvmot1vnM/F3gkE9z7LEW2I2g/5Gx2woIXZtuZ2Oal9M8uR69RSeSAhCH0Aa64aYep6XRWG3uKELkzm+2Nf45Lh9J2zjRqVj5qcfOMqyvlYSW0r2O+nHMI43kTVVgyEQVDr+YG50XCLDUsg1WJyJZ8Kl/cW9o36i5Xafpt1zml9UOuS6qC6s/hEBGOcgdSmiLOh5BHb1ca/QPZg4IHM/Ls/BgCLQ9P/X/xE5Jd5ks4+QhP9FtQxQ8BOOh/UIL3iwdnqqWT6h5B4u9+GkVRzTbSBbjQEXaDPToZQE/h3N6Pz6eZy74HizQYkx3SldA56bvnErXsdFMFZvMBW9eAg3zRnpZNtEjx6rYyu3Xx/5PnzW5Zg7Iwem35tke+gJpDmGAn4b9xA/IwVERPXhRRRdMULGuozaxhs9lientdaZjCijahYVomk0fI4B+TsYtWPthHxRoia5z2l5sx2tMDeBliy5auCeem1rH/jXgqHOK72+W9kQV0v7yomVaR+lpETk7UkZF40wy1pBZbEoRsTwvjzYoBHvLQ1fzCxmGZ2xGJuZmUTzBeaTIRzMHMvPUVHo0bpTmf1FJrSnQ49AWEcTwSj1Ln1rCGpqtHL6DJaktlx/wde+NQmlW5ZL/oQNn97qxKOFDDdVabYl1WN2mGbMYhIoWT0vt+w4c1gfiYx8aTRR51PP78iD/rJbq3nUWsTrA67DK/9Dnkg9t8XL9SrO2RShtGAwZLQM/9JmD05Byj1OYA3KRWauAti1lCfeWH4GBMCjLH9DIT1HfQzh8AtgU0FcjxQoZm4wSGZeSHnvR03NR8VXKpvYGiKrsWH2mxh/jjpjIRgbp/AHzwWE2slxj0LrFn/FXo+v+5DdNvh09c08x/KdSHmVpVV8/C5fMes16i/heyzFNskK9T5gEy2kC/sQAo/yC6gJGwxQNmOhW6bc6bTZIiiuPdzlvU+SgopDdRzD0KOIhorMnHhxv8PVR4mKX+V6V8itRBlzovzYm+p2aIfwToiRc0zvVf1OX/7lU3itle5vxMFj4S2S5dx49mimm/yszqj3YCxYIe/SFFC3tSWtpJU51WHOtHXktRJ0PvIp/VtIEanGtotoq8vSiso2dB1Jj1xdI7DIBESF6T4J2+GALdCT2XHsHUoi/zMLgkEs7uDO1x9Q394fROWyFyrWcwpYiPHyom1DOg3gkAYxI3YXNiaHUaS1xV1ahFnRIxSSgR0+hlR1g+/FLPa6qfoKyrUQ60mNoP5S/qnWIytwch0eF4nUyHY04oUFWriyZ7BxIQFrmW1Kvyc6wSYzHtgxP7NxqnZoOCvxpo/1Ti9lOAXx/a26qG59uaPGlVvVjX2DtjM4UfbrE1VG0sYRpaQgW+aG6d2rB1l6zchre0hybbmrP0f2XB+QfRUQdy0MHUJZca31LctTW1uzzCZzYdqbeIYOH91ilae45ZthzTHn2kNDmgy8V6kQh0t+1Gvx4S3XJZzP8Blowr1FcAg/nhnQVoVub2iL3nW1tOv0Dm6Lpgjaswn9MH3kI3kOfZSbpxffeImDKtv0hUf/KorblnFhbJdl4WNphEkxoreroX+Fia+aSMaLZlXqcqNOJJF+orvqkeR/lnuJM9OcfFpyp3G12b2RwLsytASVYVoy2HiRsC+dRKAN6bKm9RqwW2w0ulmRf3aZyZehAnwjvNdmsjtuIaxG7UsUB4QbDQAY3Jr0HGmdJBlp1VqZG/BjeB9UDFlhdLFCL80cdnZw7G4D/eh2WhZhYloYmCgt6jAzg4wCQsAsga68KGytytGf2sA9P1VqQalldKf8zoUXjGPBhkp+xhma0D7c+UXyVaHiwFZTVNCnG/nFbgh+TBcbWE7ZjDsTh5i3p02lH9vVNl7bBlfYW3OjlM/DobRpRoYgpf0eoSQaHdZ863w7oQ4AuwTAS7W+KMxTUPgolJrVO+r4yn30LGznHWgi7Klk8U5i+VSb7f3ImyBdDWuUN3lLNGP5RZEgP8gPidY5/F8KWE3GupC0hfru6jGpae/RzVTGgMZ4kzevjci0KLSWpS+Pcv8vaiO+TSZVR61NkjY3zYqDVFzga7JWIuNc+nB1e43eNlOdpZcjGFNZBqvuiwb0xwF0AD7O6cwljw6WP+BbQZcD3j2oCOl1EMQlpLaG/L18I2wWOaRm4AaxyFRpCBo8OtuYpVa2N3VO2xEkwrGvePlfK5S43mo3LvkAsHZCEbXzmBMJw2IIg7AsRogZprHRHmPg4fILcQw24MVnlzo5IxxozPPFrAJVlxf+tovNh8ILMmRXsmxlzqcXnV4sagPTINd15vaaDy8ZzGGjQKenbwzGcS5rH+//c4MW63luTVlMd3fKnpZyHn73sxLiOAWPc2VvdcHqxJWeGBpgLEJu4M/dUDs0L1LDCbUlOA9IkywdzjJyZe68XS7GlXfQ+zU861A7kpqh26/YhGJQyEkzdVIHqgZx5Z3Op4y4tqflElYQQYP3HBhfIM6HH2dsjPc30HgEdgB7vQ3so69pxQcIipaPQDUm9GrxeMJ850YwBqoi+1SWac6zUQt6FESRX7bZQD35k0rAS7ORYWZCr4Eu3LFTWD+DcXViNgIWoVSNZG9hKCrKD8umFR2Cih5bFBFR5lIrDL83UezEmN2+/dORw0d55h/A0uBy4evqGFpg+lO/rXasq0EGIJPccsJ2wV7NE6MVug+AMGv+CWN3TYRRmuzacvL9ZEj0hRbKlO9iH+pyxeXGnVJndLqS9G7rMhdOZ//PKvtiN1FMbuQpi3i0jMEty6SCs82Ky4+ziehUKitvMHeDVLXuK44RfBtkBOSHzXlFJvjKdtpXvjJMrNFbBK37MiOrxdYn8EIbPR2+OhXUM1KA9Tc9M6+nwMebpP0+zbjr8jAaPfUVUumOc5QoP24B8dPHRiFm1fG/szCGrSrqM/Z2v5KI8eEMceFjrJFahbMvfosNiHA8H6kbEp2LY/N9sN3boaSHQkYoOwhRu7GCmz0LJDW5XuSkM92ItHeF4CFasBQ8wHptKylA38U8kucsDNC+PTsa7kJuzkBTxSQA+A+9CcVJZXSa8+XVwlF3ggf+z32nzAvTaulnMNKA36NCHvDUwkl9DlB/0WincmpsTrTLhvv4LLOYfCjiLsv1IHY96LGJFtAa1tDZr/nqLqHEXDdT7dZR0frV+cEATFll9rOH6jvUfQ7epCofpwblT73nGOp9ftN6PDC5bSGlIEPsr/ZPCFJDYTs0639m1JgpWq/TfB2ySvHLtKQsIlPVFBIPL/oucHEf7Tugs85gRFN/KZup8ARg7ZVcF8Mtsgsl/iEOikfIVyzk8RMi3kqYxZvOxuTPmXJyG9xN02cTRgrENCHYwHkTqrnziHQOSq4/rslP4Sw1m3UZgvHctBmS0JSzhRprD2AuOJaEG6i/l6tjVc+DepebSY+rB44/Otqs/y311X8vnA3szy/6hNTJH+RvwwFG3DS0fF+vydI9QH4ik8+UUoJQt0b/YDE/fJ2zlQzH9ib+uoFnCuTTxbJ8D6fCh37LNEnPHqUTeAH95Lv9abJX3DA9a+B2JDIPMJe2g/ptVHXrPc7AkYTYj0ouVzJFOR2e84RVZh1Q1oEPm+g4Y4wUO1exD4XFXi5j6ZwNuatdAqL6sqFf+OiCsIxDgI8Bydcy+O+B4Km6jWZajanihf3mj2xQY7+icnwFkRVem6A4TnjAnlss4s0a1J4QeV0xTBhj5FVB3m19ICw1mJmub4MPECVJGE22K1LFfVpAsyq1AjL0vt1qKobkIyL5LyDVKbmU+9w1TWabNq8uWLenXUj+3bpSqqzkUX9m5vNyebPds/EzkhwcJcPDHkvs2N1FrO8UJ+rBfd9evwODeOdS4HICOVRaOFk7gaEkui9WRD/WXmvIFPMqB3w+4UF+J6ArBQRfW1mYANxsr8Hcvky5XjEMY1dsw20SrPC85f9q7qHBPp9SzuzoxFfeiZGVaV9UN4m3ro2qOST2qxwYvT93hNRMV0+7aEiz5sEvCByxeDhGQMbCkeSuU0FgTCfv4b/TKQ/CzrkwyVB/xxFOjtcOHSYKAzQaTx+YmD3xzM1aaY39uukjLp73nmx+NHPcym81Mm/OUZUc4EFkR95Qp3otoc6VFexvsqgeC0yWNlKWlStQP2ltsz3yyLwZmuMk102SPqlcLXAY2NmrWOVD/zZLHPSxdAzUNgfZcYVjAvTnXIdESragqx7C4dOjla6WA9OSnMzWVunPOgkkmpGxQIG056ubxZ9jEiBM+XXl9Znfd7Vk4p04AlVexlTApkp0zTqMDei4wLU5pz4xR/FyprX14lDPcBH9l0m2aGO02eGVs9FE/8gyX0tQop/1l3Pf9mXiJEbN7SCBaFLECU+be6yE/Utf58IvMj0cxcYK8cn6CMvUkCxrq0s/H2CV2l8B02QX1ejqhmWCeKzo7Xd/D21UtNOH208Py7OVn9sJOMZy1OkbjxNe0Dt9wjh8LW3cw4uNYVF/zfC3pmx07Lib/iniwiGtGz0BCwGQoTWrc45wIrqokhb4RWh3Spt9hzCQWxXy50d2MlWSu+0u0mkCx+zevL/ZNi6zHeVu5JDt6CDGiKNkgBp3wzjSbBukmlk80or3msf2PMfQu38mMOftipcXjopwZZyQYxES+/jBi3uGIiC7HwpumefeoDogbsLSmsRbH4rLYaiwVBos5T5LnICi+zkvAWyh4PEJNs7Dm6QyjX3W8KX5EMj1M5Yjn4kK9w6i9cJa8JFCpn/Wh3H1Ce5D9auxDiQzyyqkU34xaetq18R4JxMbvPAiCOcKL16KeK0oQ7zjMUidYX1jSk+XH5IQE0ShG7hgL0KJXJirCJMmRmdOy02piD/RF8iiaFG0qouoDIBDBq+mIlSWxRhqAf3GqD0y/cSyF3+4d7zS1eOzhFH4HjHcuf75kPkBaDW5fTYJo25dgSw5b5EOTBFwyDXKy02yOKU4SPVIZ28Y8baYyaA8CGxYSOp31CQdbSQP2BWZJFtjDdeg2+4UK3ThTgUrjbcvITrf7eIT7D1c6znT1n+yytyz/rOqWarwP9zo/yNU4eCCKec12cFfUX6Tod2ZDE9X0hw5Op6hLp+NDuJKPleqVTw7OL/Z/OCxcd/FlEP94My6pv8zSZZpaCn68y4pE8ZV7QeaW+xac0yN/92N9qfj3NO2CaQ4+vxWXa3A9Z0jEZSv4J9hyguabJTt4ZNkbr5Cjy9izQrI/5Hi7vCo33V5I5YOIncMvBZFUevdWXdVvSiv/9bNkHcZ4vQIZYih6F5NKSctTWXAJmYhk7ADxsmTse2B8pfLLCP5rUjkhvNbYXRdZTeWpz+zeBywHdvLIsTTIzG5lHMp917ypMagJp6QYi13klH4zczhwQvdG+Sm6d9ErPwYo+r2Wjr0gd5oesE4UTEa3xIQozbjTZmhycCRbT0B4NFkfFgqvWpnqmwuFuAp+5r9yix70sHYe7RodyGJU4WDwNpDxrZg/9vml5MncY/h8Adnv9gpjkwmdpnHEEMNz1jsMRCkeKDOfkAH7YFJoxIsj2wQVhSD0cTJZELk+HXkr/UhuwFP+hHvIC2mr/DjnaGPX9cU4GldLSCmlvWNEzUfqLwiGXqTSC+i7XmX6rC23FoByeDbcFJscIe7PfTWOBM9ft9IX2cxfX38Qh16rIb335VeP7a+lJ4NTjexpsTvbkVR/tayhUrzAHssgCw5pqzJh8XSvveFRSjWWwB9UBTXf7mh5bNH0LB5NPrvVEvg5/ryRLWW8sy4RkBWfttNxQylsGsxJvs8lO4E0AbYyR0ITbvm082oF7ZBlQ93HRVOdTLS4srNtcu8WBrHT8MlajGVG4lhsZ+pgmOfZxn56SCHcGXZ9VpwC6W8yn/Gzpacc1uIt5ABZ2VrTaKGlQjIah1DfdXT12h8yG9cZy9u42E6LKKMeoYVlwSO/McVFQVDD3RnbQI0pVOix/acnWvueN8ORpb9U/9xJhT8ft5j5qrTp8TngjSGdKxha2SqN+xGg70ux2LD24AQ1FerOmhte6u4Xy5s0XCx/Dz2m3uWnU/zQZbdGtpKlDNzJgcY83FQjErMOG3tIQNa2nXRg6WYCCM208PNaVxvTXO9/grEIwqMdSRedYUJs+kyc5a3wtkk9U2pJN/JU/JB9033b/jONtOspUTsiRk9vHV0umWQW5WUKcKEpyNEK/AX8kvZh/bdG8wxJa3oMG+NWggxCDX/xMDfpyzzCSmAf6Dtbow23TpT2A/VlmiEPn3DVfky8P5ZR/nWi+7fan0VTb3DWt+oYgmbAEnzV8eQbwnCUefNlgn37wgRy05FaWqN6W0WNA0i5wNYtRxIR/ryNBUZaaaVMao0ffu2KRweLdDwpmRjXej7IGoM/SrP/02hvnDm370MbPBrqALah4vApVBjNe7tja3eZijyFLRvXxpmpHL3VN31TpZ0knmK/JKT0sOPdBO/0TSSBXv/DoJRRZCtmxxCROic8VvS5suxWrEshftKqCzBHhBgvvOVwUbVjKuIDzPZ3HUGSJlhnTlyIJq8YfoN1xdkk39hhF3pLGObHzHyoaaDZVB7fmZFXQYziG57E/1whE92GJxsBYF5yOfA6W8NDDpGSLf4/HF+27eXrjM1hWwNb6YN5SzVLAIbEjah6o4bJ4yoNqyEwsNziv082Qrp1I1Z1ksyFhXbkT5o6+QSRwlcDtgmlacRshxSDK98Fok1/lhFmkhhIbOoQvNmXWcEQo74+/bby1K8juLAfcBX3nrYUBX2zW05nDYrWSJvBT9dR/oHuARbjlCyGlwhpOO01X9ms9EDbBmKoa+A0CxIhLE0/8PZFPd7sToY0y5pznOH8sRIHm61uMDGCvT9cOQtU0gP00s/uzz8Acyyzg8qoJAfrzedbg9Xvo9cAne2qMh1lUNFyCmRcdAmgtAwO8HvAgZfPGjoSR2Lpvkc/2UPc8x14q5WeBr6hTCLXpi7ZHFUsSMZC7jRy8WcH40P1VZSdGtkLwT9kFzQrV/7Z4TgpPq12TfjtVDed5Mz7L8HBKpHd66qdftQwxHmC3HRzIFiR3wSrjUt7fE719GFIetuxYxfdUf88HBWoaZUEZKjA43VPjDiNEF3OBM1lIT3GmRkIWDrVCuo3LxZMEb65ekGGCzc7YFKiMR+F19IERzzAG29LqiafWslxO8ZPkXZ5qYvj/I+4+MBqfktaIf+EW3P6a4B553RVSJ3oFngtxOT4J6gJHQhwAbQbWtA8gGPbMKNmnehKpP+uFC/tDGLjqDMvPfNdx8L0ahcEa5hZkyxhRJWSESS5dqen3tdUxSYRsOEV4ZVNsehFR0o5ANLtDs7JzQstk/GXk00iq81cllVta291OOVDdJDoQD04FfNgaqhW241MDTTdE8n3f0a29GTCJHExxkrrS3713FP8fkShb8RvnOnwwKjHIO5wNns0RD/4BpAog557aPgRw9nx7NoM+iGt+41sIE/mG3l/Zjf1yWnZ0f3CfnXIdgftS2b6G0Kkw0BMCiLtIHPy0UaNLkCeufamxncWUvBGioVMwlaJvUBTwMsxXjKWLQcJr+HbDVn9YLfcoGJqaYRAKQK0pzSjabi1IsxzG2AksknUsKo+bOhXyLVnMkuN0jIsit4E7c46zuZrATS7BQE8h9wXk6v9jO5ML0pSzv6/1MFQQiCR9q1qUOz8Z4QtPB4w1XB9/fD6ozYg5xTSDg5602i4WSibSVzyGrxYn9M7TezEV3LprzebYBBnKsiGgRv8jYRc0UdJSJS5dA8N7j1h99CMtYs1uiQQ4I/0N89UtHi72790i5NOL/GF3BJmyRtg7qt2VmiLjQ03CglZUmTxyuWao2fYgta3CI3aSj58xPpDUV8cmkyI4VOY51Cpf87li1CbXeOdJgaDlStPkWGsH7kzcgY/Js4vAWGhj4maX+AWfkrevOu1MvnryknNAq+wTyVCVD8SHSbMxykh9QkiuCqcnlNYmKAzaF1qDznlGGKilk0iTun3nGhaELamUDXdC5ndNdRG/zSGRA6ncmYwBRe1+oArgvmQg9Rjqsho0V0JyeF6yxSP6Gat78krEy69DpuXP/G6JaQWRqr02Wn7Ji8Vng1FkA76T5CnjoxDEE0VHYa3SCQ9trQMVvEtPSboL0sPpF26nfZEXKKIf8t55qatVEMscO4eOTs545SMvtYQdCX7xI+IxRyKMKSkaFNABADMXK8yz+R/lOJ0SxtzmwBkTjJ4i/2SAKR4KOvxiJdQTQ74y88wdSaX9ZJMs/unJw6Hx9JUJ79e5VvM/Dy/6VHtkaJiu9v5pyJB/1LgUJn+ucn5Y5W7mpCtgxTW70FYd84wII4DaGNetbCWe8QuuaCr+xmybzMwmPfhuI/hioTbACT/0dRKnJHH32FV5/zYl5ZNwZ7nyBLjzud/q9GVE+mkduz/j8bXgWv9A/knLvOi/TBTcPOQaA34DtvBal69EvkVdZXl7kbZsden7zaT8dC6POOZGCjdgZEaech3fCxAEStgIznKKNNip8VFaQltM47DHh/O+dOaWk+mY8j5XfoXP9nLet+HVslDOttdasM51QD7hevDIMNTYMnh/7F6kljDyozwgKj9w8SoIYrFAUKegDODqqguIesYHUctKcJ9yrxD+lQumbGtDu9FfJd3zxrtbHiRfRsmtfbw+cpx8ivP3bTzKtCz572z+39wOZ22FhnDq+Pyk2dGVxygbm9XlknvMxLF9EfYmRT3HkoYsNyUkOdy5FZaR1xwpCey/820GjyPCaDphWJF3AqVays2sAqTjms+0jn1Pvvzsjf848Q9UVubrRS2EhqjStOHwArs3JXv59JpTheOCe3lPW+UXyTu7HKe3EgGjD5nYp0MxAostAen6mqsQdjmX2qmRftBUYZENQBKgfx9A5ylA//BXVO4myhqvqsIXmFjmx/dP42/OiJJiMu1QXPX86RP90knhXblzd4LhmL7OWh4dr7CoL2vNUkYADR1k4aezW/brNvWv/AE6ll0nfHbweQKNpK1zs6jTDX6UICreRFKQvLQzscgzPY8g/4oqV7jAKN+n9JlOpa3CmHVXxQxIZnp3V+ZhDDVYKq3kS73qL0akq2guuRAhXraMH+wFZ5Z/F3fjln0BRlPqNjc0HRnZWnzmwTvnfI984+qvI1PwTBaN9ZUhfTiwHc8FPEMnJidQ0ZBxRLHsE3Fz5cftqxhBD0e7ZDf7QTIAB7Q34f2tqIIb4VudZMfrtySLgA+RGntnCPOsCMse6GEe7HmxLFur+xWOoXE/smvM4ZHPjOcel5GrtQHXC4N0irkhAMl5z61ptS2k2HLE/ya8e860XEqLEDHqoDaDoYw1/bHRnk/6Ip/VUWmLql0z1aymKSZUId/0nm19XUnOnE7t3jwKRpQxQzogD8zVKJIy1xQ4Dlu+Tu2QB5s2+Yd4Vik9vNNANxlpL01K4e8YCodvBDJWZwiCIDcqF4My4u0c9f+C0axp86xZd/ksfxlejYBZym1r+fGJZYAlDdIXI3DtWu3bzaNZs53Rj0Bxp08UHBslvQoyh2KUQuqMnKk+Wjdhi8jawAqeuIA7OCqEtPNajubjj1NRjU+HNMdd6o4r4vYLFGtU6lni+wDo4/CGlTXmErSnlk0UVZOhp3Ts2gTgYTBnJM/xVcWxQrKwK+yWsmYNEf5HA+5CsFYEy1xffSuRjLxMewN6Wnd47u6HFGWKj4aeVaVT+HhL8Hwovw1yMcDdz5NzV3oDVoquVEk9OGihVtS7Gfem8dd5qFhWbGIgCsJbhimLx/FCFXUb+2mcBs1hnMYc0nlVmdmTRYkovGt9CuJ3CW33SRc1rIbdTQF53ODJdlpAMJ3xJYaIeJjYnyrRPaHihab/lqR9GbYRqZBUBeHagLGV3QWGT8MwLchrebj83krX0RWeOGDbpHOCg2i0f4yuQ/snabHnr/EJOCPaz3BL8AqVzUaSFHgtMM8TUfrmsgd2w08hQDKw3yyE2Klcbjs90GetoyaNBBjMYGMWY6PELV529yAdBejLBcgTQL/RfgoIXvB+Y/y6lDyg/hYf+HQD/YsjNZKkpOuDpR/YF70pXzsFSIiBH5B7itVJ8C1OxRP8V6hu6Fi4DO4lzSjyAJQTSsKWOJLhc5bow9kqKENW3PpAOzGj1C+AjtKRdSj/yd3YundOqY8DOyhdtb2XVP1D9SDxt3HkJjEFrFrKxR2INfzW6N64REyHIzKbkwDAHrkR8HyteWSBKNhu4mmgrzWXTMIIfxNfcDIuj56rggHM5WMZiChlg7Xu7DnwOqToqLOqbZmE8lpkBMsxm6P5xoTyhbDztyTy7ZXODlm4bBHdRhPafxuTKSprpoQKAK0QRr0ogIOt7deMw+JiOiaxMpm9725NtLPc0lK1JbLOrcBOQAdKkuCLlbed0NQzOPMDOPkkRaoqSaMFPncIpLkxbAD7+/CGrw+3iMc5OS+piOS6jjnruSdDqq53WYQvtMYPHz4X5B+E3ZhW9u7HCw30ossfHRzCXbLJS6IK5BiqLV14RDUrGJTK+Tetk1kp7Bqj2mwW6NPRRP/evpIQ0X0QFZ70zjE8UuhrQMRkRvYUEGHgQegegbQlDSqQlrGRjrY4pBjE1sd0fJMss0AbHEoZ/rCNSuevoV1ahSTIqGpKGubS/3CxEuPMHXzUAck6+fSQuefE+tht9jgCjqsBSVdeCJN2gIVq09vc8KaZ+CIed2LtYs07gvO+U8X/JR05N+MAobNmLvA9+prvzEVmJhTA4aamkHdXa23OyhBeYyqksmY+ScRk7CXcTX7m/eyvYfVk4q+UUJOX/gZiXL+n+m9ncw1OcmVTEnPHLL5/8oBxyowchwCQta8vYpVMXZEmpdbNfRaGxrAc0fp+DrPiMMQaSBSPfI/RCxXviy3tO80oq8PMn5V2MhoziNhltvcgVGoOjhkWwNKs5ump2iAaN36EHtmRHuUOeB1wn+zLysKDx3De7X0yH4wjhrsFAEIp1dv9O2RrxCdyeJKiDiad17dK21aJtREFKUBKCJ1GBM6F7VXqHgxbLRKGTnD9SZMGFB69lIVrVv7POiYwciEI5Yt7nSV0pqNAUGtBaGKobbaKLbRYX45sxGFSQccHl6blez1qTHhAjIrR4b27vu34dtSq6RG3K/lrFRg8xI0c9ww4VMnf24QThxZCSedZDx79Wqv8JuKCyV49BoD9aOiJKBZaGMgEA1ERmzBPNuFldfcFDJ6+boEZCbdXhF5lPYVp8ym98sgSey0En4kitYzVbmpguUeEj6UWvSfdt0KYyrWCnqg/TB4hEv/9n8IKFOHnnBBrKtJ6mEgagCYeiOB8xi5s26TIwbu9uTpCPf5uja4JFYZPgI82Ty5dqlbjFqGAeJ7wTUVm4iNAueesDXwX+bRTuRlRWfIch+TcaXGd+TmnRnfIPPC1S3aET2zuSQyGcfyCoOFRBqXIDxAvrqqRTmd82+SDQAqb3LiHIQ/uecWpSN73UdFbHdV3jjD67eWsjcAoq70Hx0lJaE0UQ6+RCxS8qPRFQyk3mh+YADtnm+sAIn2vryJFVzzX8BrEYKPzyHIXHyFfW0QGOPbbUbD0AFa2/IDSbPoGa3czxs7PxCyI0VSyptWPq9EYrpNhqmd1YrmIPEGPWfprwHWIAEEkMU9ccXafByHCQB3C6DkMXzm3IdQ4ISk+sKW3KnKRWq6PShcmtQlTMXyNdECGnNSSZKXqvpkYJogPd9w5VUqWloH9as6lm1d8AJV0ikZpyE+fEi1l9L+Z37GDwbLLcIF2yogoZSf7ca2Q4RzGaMyNfT6JneHcJqaFTZJxs1uIntelHL+8mUcHBgCTzNiXVxx4VEgot/ffcpGnVw5BXZosTC8qpx0wPHvKDUZtFmON3oxpHG9HSm5WuanuloxLKTeJNofd7g3HeoESdFH5kCuk3Y/Obmmandv6XPaFxe/HBmQwRnFj/H/nu4IRoFOuN9m1d4jUaqeiYzXuX/eyQZyuVorwJmIEsr+W7O7UWaqBBaGwuO5dTWCcz4Ksp98tD975Em/A9GC5tVaixPpFNcK1eJtI7G5do/zSP5L+thTn7VS21qwiR+r+wgxS5gUjgn/c/HWEDZAR4Jn6exChyrILHq0GU+b90YHpT8PfrS012O1RpSrjLsAU3zcEVxXpY2M/2pNf+9HVrFS2sEvLk6R20RaGEW318DKK6kHvQsr2pWPxyqamCqRGSqUIJZQIKqHXmOzMtwK/qbribF2+q6Vg6NhhFL3+Jkzh1HLXfYikinj3JpQDQZugpb2DIx8TQayFelPOeNp8rj4DQNHJldPHfAXFD4MxM29YOOQu/xaDTxftgat0JJB1JCrbWnPByhopUhMnRbdiSJ+qTRTelcq60JZA5ZPQrlwApfJl+BlWO4vbGlpK4P8TWW5uNAMV5S3G9+x0YcL5zo5Ok4mMazBZ1UsU9lY21VwCgCBSc9Y5Jq/WH2fvoM2n5nfLLfpqHovK/wSZP2hJMvKn9waSLUhzyqTx+yT6iLx5FPYfVPKxS4Kx7OOt/iqamoLjGKt3Xg1l3kaTjGIBWLeTwEg93l2bXYfmL2bQM6uOcEbSoWPfj0zrfKp7gGG5Vuvy1/wCU9Xm80N/feLq1HncSXf7cszQ9WjqT/XZ+3lrYXax7NUDFse4s0bNk+DNej1qKC5PxaDJaWsuMSGg+Jy3H+ln1B4/RArrk4N30fVxJcT+X7HIgyBVmMgli9G8m27Mg2q94Z6Z8vMlp0Q/r0IUp1FCqTP53gd8luHu0e7nEbjrMGGF7srXeLMRceF4jTgIj/NHVxhfhpS4WCFf1adg5YvvekmMypsLORWuRKW5OU1TXQbceQo7S1xfYWcKkbwoVmgvy/gD7RhRKCPJYSoCVJRg5EMIyeqCoLaC7vE+R4MmxuWQ+3i0v2PPiby+DLvWyjKI/yY3nFF1iTpBT+Mk5owU51WApDWdIx1SxOKpM72wUael2wUGPLXfD9IkKdho03p/SUVYQcqajazMAielD1YSpkNAcaxSyj/vmMOKkveLJBWDeLC4Ye5+X5FQETKO37MfngGyzo9dNZceZTIi8If8pkJ2uIlAMgIa5bxj+Obp/DGqPxoWhg7J8DnJb93OhN6lVnqlp/lKb0JjUa5SlHFaPwJjQxKE7zIrYIijgYhcCyerCEmNFMzJfPFzCkqVGY7JGso7gWRe999LjCLQtZxrwAzIuj93hNBJy+J43k5mkvru2uk/qiwPLnm3AfAipi1Ex+nGAqHKrMZf+XoWzuRN1z74RHPut3gH3EVJgTcT8ONAE7DFVq7uycxtyvJMRsdpXnBqT3byQeJJJd2u9c3Pny8AzBNQiBdel6PWsELUcFPIlKI5feyxt6TGAPfWT0BefY0p4qwOgIs6HvwWr9BjPWCRu8DKVrsm6Jx08kC/jczFrhWBeNXs1TSbUlUSbtYnJI+fK1wOAmEmHdANYY1/fR3WCJ8wpqTvGZ3+nMB7k0ul9p80g/Pp/Y2CeA4y88HFxNx6aMbTQ6gPZckYFR1feiXadhL0PTo5y4n/blFZXOEmNjFHw9AWbUh7dsw7XBr6yanh6cPFiQTJuBU61z9KWAhVzMb8laYjEp8xx+kdSiYS/fXsa77IvebQY4O5n8P9trIrOs1W4WslhxgwKHKrBJ6S7WzsoEoDXNVDwk4VUmF6JW23qb3rNuiMXj5UHNRxEg44ZcPITMn9Bda58y2phaa5Sc8zpPws4XkRgLQ/kQp4zNu6VgHNkLMjnn0D/X/juqe9M0DyuLW5SKwhAhfd1aE6sTp2rubNOm7jGlH/xtQevrkD3jEhbSMRKqm1Ll6udnIIPvhjQGEzQDIEERbGmts8PX5zH727WnyS29+Wc/2vyhLfAeRk31KohD12GIMW6gx6swTrxMVn1CCib7XEGvjVQ4FD/DoV3JXEzCKyo73cKXK7ZTI8yWj+9BiEB+H/wYzGTBlM+fvd27U9igyu86uZiMqape76LsKfxfoauiqBSN1Mx5ZVuX30aFTLXBE3xONlVMFPX+/AemiJiLd9Ek3Q9svLRD/WJN0Bq9BZ1QRNS4jKrzd4oKZhrvY9b3b2j9E2avCzFPTnSKC7JJyQhsXrtEREi+N0fRAM5EC1FLsjtVhrC7uHkwYacDaW5dOI5p74yy31Nn8/d9jaVUF798UKZw4g+xepk0LxaOKiLaz5GmHEMAB5dorGAGI2gLKtDWFGlErS7PNEg0DSrWTObFIv3tGwhUBBX5rfYwKYkzEYKRphu5vR9TsUx4kTf/zxtKsGc68B/QBakWRdYJ7AWrHcIOg1RtZF+hgmDNpbzOW5G+gcfTgxWDli1eksnUfWtw9HuM1hvmNlb1Hkk7qgpQVtuVplaacZl6fBogd0zHtMenoE+zX9P7i4CHkt0bOURHVtjr5OvDP8RSPDfZDfDoC7WmG5ukjw/QaDEiBXdRwV+u6BP9gg5KtoDCM8gmxqx/1oRvb+fgb9wYbU4J8kxqiYBV76gLgDWc1ZhoMA3d8wHgJS7xV3qnKpSHxQcq7b+4BZlmJGYJQqtTiYGnutN9keB6YqhdHRhVAS8bEwTHNNP9BIEqsTiiKIXiRD4Xs82WR5IcwZTts7F+2OrbK5nGuINPCFNVTHad+UzvRmGlV7uO6+BXr0bVdH1K/2MjsvVyy3Oj2kQNlR6TGVwuDLW3vC8p22z72d51mLaPNpBlCLDSy1zxWOTrmDAzTBWrE4qdxfh5D/QyQfRJMJfy54QQkJipICy6hDkIeQMq8725v7QkoGlHplp10197sfg46EUkGBc3l13H97viDJHtnuD9BiJQJxtoWd4fOVhIZgFFIX44MKywuG75F23jSLx7udUXwAa8tw3xQLZsxoe2ec77wuVQRkW/SN5SV4hYpiGPsXLedBB9wdhbuQBPBad/vitFwp9WiM9MbBfvbJBDXXtJdGgvLdPdp1+VEHmf+J6Ly9CRl4VKw6c8qybHUeDQYRgWdvf2dD490uSvc9DFGieLaACmHLRf7i4x69pK5WfhUWEbsk5SUfI/s/Mojq9MUXTFRSc6gnkTOSckUvxpGGY43bOYsr0cDyZ1D47ZcUC6vEWbjyvLKrWHdo7sC3z0OywmN8nG2+hw6x2eSMHWjHftgyh5c2NIG+hdNv+AZowduw08+tBuNLIxqoyKG896mDjSLiVu+FyOwtY0wnSvvv01QlfGQ8od3izBAaWzS4k09K6f+595DZ2uBtQdnvaTDlcpRVC+rVdnHs7ct1OC0aaTWf4h+bknMjkN1+hRwz+DUi1U728eL3cRCcWbpL2m0X+d/5CLBS7xqEV+lt/dhkq4uV1vVYv4JJn22ZRr3qH748BqAwjrDuVCUj2t0vjB2QY7eDwfJiy9U+T5t7hlissXMTGdshdNPY2B9WImiWeI3T0EnmsegYT+S421btH3N9jl5g9Ffgn75nYKtpqWE6mU0yepetw4KMaLTvMkkr/efDnxqRZu7Qx6Bg9skJZ/mSV90ECKTNsrqH9oUTwPNQkp8MzSuHIbIB5ddMjArWCqVMM2l7hdnyKv8Ke1tZRN7A+4gF5nzMJCVYyvjvIrT52YBq0iLTeB5hm+TH/PI3vg24sSPg5YUjdXs5L+TdNvdKGSCfZuauROGZiezj9tD5B5P+DHF+yQ/WaLoJitbcBJG1At87w0RBzD/ymIZpyR9dZaF1KEhev5R0TTcptvJDbOFD/K+UUSXTPXrXJOUM3DTvYMD8DHtyJTXZUn2FwQwh375yl6b8iWN9WMaGVQb1xsNRfXLaLdOkbqcZbXzFNVlfEykqQ8qrb92CfPRB6i7QbFagTFVymp/BeMmGvg4HgAxU55eRStSD3uAuBCTP0vWWydbFodNOcjyPhVUqVn2M6ESub7LZIZhSrMNRfr0PX6GG1mQJS+w+3Bj/NPhNE4/2n9xkbYjRUDGCUxqnziaklA63iUWK59M+29bT/QN8+xOLLyhwdBk9DPJaqLwtnaURSiUMeMm+R6y96V7Bzr0i4Etp3GIS3iDAwuHv1MyznzmdrV3gV+DhjBxL2QkHG7Z2bZbH9zVnoELVDAWGbZ+6k+dXlGNxxf/GfP9yX9vs45+f7Qf5+2s+f7IV9Xsafn+1xfJ2Nx+T0N/k7rY/J2jvh23h/V7zP6vbx/yvep/T6F75/txfq9vS+b7t8+TvX/q6hL5/TX3z91v1Udwb5/rc/q9R3fn+snfJ1nnyfUCvn+ovfJ9X2+TqJn5O5/0naLPx9OvyWgMdpYw1aQKHiy5RLm/E65VoWP9YqTrO2pqjuCGTUi1SdFawkuwcxRrvKKfuxCBTQPfW7XlyrDVfg+vHQI9NUgGnICg65EXDFbIP6A6SKczjn1oOYYTBvXcVjmTQ39zrhWzYGJAcw2zdMOS0C+KZGa6otmYfxS7b2gx02yY47JIxu2zy5IWd1b/HzQGyu9XTEr+x3KeBLNIjCawmp+jcBBiVCtbxF2eXx3+e5iNEkikmgNaIoV45VJp4BGrUXhTqF7PiISPgj8T8z6AxL0RsnmckmQNuuMnBprhsansBmpxXVUeDncypGed0cbowfd1ecTz5y1NHbygQG4O5ZkiYCxYFx9hup7VeAE1BwjxR7Vqh6qHOOio8iXY927Kx6O3+0qTmWdRIHTDUu9yOsqhenuj5eBxVpGjbU9HlDOetMpOuBf91pNrS0C3zouF5Nco/zQIFwv0c1ihxabmS6jQ7ryHhUC8Sfi7iogVqmP6s4oWztm7kpHwEdvZ4aYooYxZEJbX8uAXh8ljz5yWhnKxWRyys8PO+S1f5TP/8nMNGfV6xQ4c7RAr9xu7AjipG56yBV71tdEDz3ZiXVTToDQlcRh+R5VsinG1Go2NBvtSMZOdPMdHk9YdtkqwHMy9FzKSel/kKuhaMBYRkk4HLzo9LTDLK/ssByvlm16QBOPYFVqXHpRoAgCGqkADmdsnbbuIJDl05wdXCuwZfM2eijnE/PwrqjgIEOflxj/fNkbtxdCuzrV5xew5uual7hwvkqdT9SmFRi8f6UBf8hEN1+f+XEnDdLPdzAGxCx4J+W+QcX6uhHrkDYZsrZ2HigDvoIdmqyyrRTWjDa9/HWlgZ2OB2rzzdZT5Kg0eqkEe3fHFaUkUPvmXp2BHVW6opg2cXZQz/choX74UaAMNBPllkk44cMnEl3F/8z9PAeWLhEImxl3IDtpYlbEDWrWROopoBgj4ZSIjkbWhuBlwTliHEXsW4N8X4dyxppizCoYByCe2CPMWZBJdDaItHH73ue2WRcsljJfg2PyMTKqIQx30tvM6wSRdShZm45IJ+q4TAYtL41us1721ipiS4nsxMcxETyYvarRAa/sax5WRpTiokpOwY3hCyG80K9FfVq1zuaYbs9emEueDZkdvjryJ1T45SuPrA9IFdn/Bk5XefCLHA/UsOY9Yy7x5lAMPkmwbNb1lFmQo32CVffYzEvEuitU9jNo+q4MB5tE+B8UL5zZUBwIbLWy10n9wlsLzvrXwAtQ8UDWAt5Cs5ngclqgG+Wp2Guk54I8LxLS3QlTYF01t5zVYsoYQRz7Ow3R0ECIf2DU7A/ugXN4+1TIwIzKrJvYoBhn8ofOhxEf90egkZ3l1pcoAaOBe8Fq4vT1kS/9OIRxjIhcEjVxfjG9FtjJBcCPL7MxAN+P7DBwyyBvt2cwNLya/ng46JeR8XHXMDQGD5bGXOFZHANpUuzPpkbkkiwVkPKArin/I7Uh63lqfa9SmUcnzHUmgZuemuyFG11ZPSGp2H08ktrwFWBNj9PCN5b5jP/faSH+Gc3W9SUcTvX0eqzzbmtECDZeON4ieumQ/nI7+xwikHpgqKYnAyM/gz6c9OOPuD2+4i9JeHu7VY9AqOaJ9B1YNUvkd+GZCKKb4Zcz4MRbHvBbjGGyatTVTb60U4iDa+CeIKip+PkNkq10g6ldFlkuudvMQP1J5sReVT0+Wj1EeXAmU2L9Vdo+HWnd7/HC0uDvrB7lJ+kkSOps3oZKiYwOfqEVwXQfMeXZUEgJF1hKAvfFFLHKRbpelmgVvl688cGWa0fGtV8wBPNLvRlLnQf9wYfJCXSi/tfjH82PcmrEMEmdYEDtsvJpltrbWIoniQ15ui2TsZx4pU/vuwlYbRnlMGe3HGa7lVY4Rr3NZ5rnXh7HX/0sEVonBlYxz9P6Png7HuTxNtxvE33VZDtO7RghD2Xr+5GRH0Y/qh9xDgevwhOSkRfd/62553uapuD22hWYQWr8fPmih1aVsFUMFxiObtxQo+gOu/z7Gs/6VTGuoUThdCOGUXHRaw3PO0hgwtTR+FIeSJcWlUoIsv1KEonIdNg1I4Xkq5D6LTAy90jkkgCTRWL1TsIQcWiIHHIM/hHYjWi7VtuCz3WLnWFZLRkQ+tYFj9xlRaehFfH+q7Qth47R92Ohh5jkD+7quPz3vgh5Hz3RFiys/nYCgqnR9MM/TR4NZABo/lojX/ZDkk//IxHPZoFKVru9w7qbK/Y1XUgOAo8P1WXClsusAWALKCz1UIEJVc6N/wWhd4HyiyV2WsYLz7cSFLLqFRpWTKoux7B0/lb4dtiHkZWolrM5dpCkRk/fx6OqwoKjusNb+Ag+i2fVZkczGXhF0gKQ+jhl2i5oqsgVBpS0CRY+M1CBFpLM3Yaeni32VB42pRZzMb8TIc3FsDtC5N/H4lInCIfjjzCrrBbDsO34K193YE4he0nQYu1iVbsnmJYYIv2Xz7YmHxcrmTinQw8qnAw/bLa4Jj/JhF57D8l8ohy7UIcVGL0kTXH3qUsbL4bDNnA2qfifUR5RFUi4xK3KyET0CG+h17RJ0ApcGWPQCIeZBmXwOgrmkEqOFK79AaXc5G6DjHKeuOItonFb9aFJEaquqAre6Nq+r30P0AcdI2M/ZdeEI1/Ypx1CWeCgntFcoj4ZQgPVicvpa1ZHshcxZo11CRN5voW3KiCuRpG4Y30e8C7OleM4elZYbLmxvNyGVuP82laPAWfywZT489/DN0saUiCvM4CoPk2eZyVLvyhQ2Or+iU8xlbSng0yymwr2gZjv1vMYmkJIbDaP4W1o6Xws2y5Z9MGWrrhpkenDY7GNA4dw15A5n6E1Eza2toGtynBAdZhJYEZdFxpNOYiIlQKIJfUpfULSZSjVhG2deNb2ox8eMTYJTjiQTlHouD1aJ1XumZFfzCktiko0G3V12NG1DEB+6KUrAxRFL1m0zmzG19oqFqK0MNHjctbenV8plNPxAYsgri9Qzjf7YJkKSQAmX08hNPQdeRPC9withZ4h30HAS9+jtQu3H47KYvCp5bSszML7NcuR5wC2NOi1/8ZMKpu44oTbfmlyuPISks3657x/XFZqEnac54Tj4/c0vPelZbYV6yuYb1DMH810KPBAz6drd56IiJqD7YUrj0Xb/1qmO041rEEkc0pbFEsJpkOO5vxkqnGUx+pC9jBBFz5vSw5ysvTsc0rJrS5/juCsCkWt5M0V5Kjv9at1+L9bYW1W19ohBBoGuXwRGmhDJKjrEXAFjWousgyy3moPOXuIWL5bXexxh3H/ZrKBkbaxbyyF8dHpI+T499PnsqljzYvrxiWi3mJghHXp7gv4LyO1gEM4hyg/m0psB2fr7xiUyNHqpD0Nt5ZzQ9njXUE/OXWjGO3zXQh+Or7czD9gRMznL4QSmkTOwvso34OsWnbl0glushUT2YGqR5/SAqJxKH7XPyCS+A1GV0BlRZssKWPKCOy82YH2eUJxYWaU9Mye7GxLnb2FnrsCMa8cQF5wHouqOtAmzKoY67ZaMZ4Z14ebBtW07/YgZVGXzH3HEFrwrzrEmIGw3hb3TIMEdUXvGjveRWJgcyM71Jm81/6e9SJvdLzzVX7vzMno1pyG6cgdrbm51ImTLWfqdQZqX5rrOuhCuwv1ANqCfWmw1G1cnuw+FUSgRH7h6X8ZVjUe5p9BElz63odTZkSzWvXqkQlHzhyo2ERIJhhqkIoZsSJZOky05x/EgaRUdVTTnRLW5jrYjvZrh/AM/wtexbu0sI41vrpVHF4FknTglh3YMTrCLaa5gTCNBtMve2RQAD2KHApL9EEerNXZRwTNbgdhoZlXPaNjt2of2Q6u3VZZR6gXotZ1pQgJ4q6RSF2m3HZ/y7t3LYJOzc6ahPAUaXvdpVyMxkaKhHSiWdtKSTt7US52nOyFNcwZjwJH5O/CMWPTAuvgIxUROQFq44r1TmkmbX06CoYWTIGUupMKjJa0qkzdvFw+lHurYxyul3Zu1Lmd4HZfzmq1bT2mKwQbld8k1Q38lsjkQKR8Ant0KFX2ypwSPhiNBe1LWXmqynlSXoLbcNlPaxQ7yML33H6QGy3CdoASFA+HFc3+/xmNw4oqa7975/NlJwoOKl41EZojHStRgH15VhcLMVzhbJVku+jCkhJdv4YaVvksvr0DCh0vvddYnIKJSuc/HFm9D56MazBLXXwU9gQoCKYMeqQdEyzEtHXNs/oHgHkOVyz593motySzIQR98kLb7aXoOcRqRe3Q5MD6GpFMSR5vliQPbsHg9bPt6/IPph8lsk1B7o8QVGlVgHPG9NKtjsaE/YGB9kGj0v9B3oj+NifA+/aUu9PYLU0vEDnv4R2D2/jXtZatRYfTs9qg35d7BD2BgL1U1zbcMLSGTEtyYRyMFOqfh9QwglN+wIGcrDUu8V8+1mXBpcqXUFRcC/jsKw+k4ndh33qXwsWcKmk6ktjw1c33EpfahGYj5sOVUgANOc8tN4SDdqEmrsDhZSIfne9vREKQn0a6yI/qGtrA4AWA3P+RzX0hijRo2CvfAFgkWMqGx7cmVF1fKqIHuZvJp8XBZxgDbF70Lf9yn11Gu8iObfmUxOWH1lpQ3esIoeewcg9wWQQKh/9ABPsYnrBaht7BJcZqenJH38lZ6jk+/Bcm+/pHCDJ3yj5wU6UCr/ebWaF0tahpI3GHSfERCeq5bRHcym4O/d6HeDazLKGjszIdEy3f11xyn/vpvq5WDB7EdULKatmGH56FizZJg3DoKa3YQPG+oy6Qyca8EPxpA0x+zsMaYMBBylRsSnpB1Yb0DIrXPnS6Libi7+fH8t5GZoxODbMWC6hZMsUOZpa3wTY0Nz+kGxXCZ/vDELTU8qQAeKHw6PI/JxB4QcnXHlI5UywL9m6h5o2k2CnrhHUvpvbL1Odnm/dU24qZwijmHiET9lpJOL4ij5zv53iP9VnWR3wIgFg3HEof8f+L48hvCnKW17WkHZ+6PunYwNKtwvOSL7pW2J5FpvSOcv1jKUcMPOeWuaDesQhtYIp7oKDJNK2+oreiTp9vrWvzRlg3vtoNIzsQ2vpeJWSrY8QhiFqnc8r8u46uRR287B3dFWLqrSyeiXhEGnvcm2imFJBXTV1s0Llm50t6/8Q8Kh/yemrR37dH04ddyLmJZfN35IMDXBV3i2nl7beJsDUqk2CEaugzgsb/QCqW4tSLLjYgWUcKs2wRZz826KdXcqfbU5Hd/C+uHNmLwb9gbPQOy2S0ZKrwfAbV7lc9DwJgsyothxAMBdv/WRbDI088nVlok4LmDU2wTYuoerCLipqRUsMYrNzpHYMa2ze5NvkibNSjby15EmwMwQmkPAv3Go9Kjrbm5InKEoRXzRkXIQtCVgouZN9FCuRnWgbUn/RA9yIR9MfY1zGtC6pIl5nJwwZuyd0rTjvPuaQY9EFFL/VH3QBvocfavFXnOR+QqXjqaKvjFb6g0W7Gkg5SrtoUQgcDqVQE5Y9X5mpQ+dayv2rv+b8VK5q7td7gfgtS0ZmrcErxzoGvZZLpwCpXuDTLaaZnowRiPQsJBMnHLUZGCa+Sv7pXxZJcSe2e7V8G09gQGCX4dzMpJIqnQFq9z4tnhc+MYiUgOXOeI3HAoMVL8bduE8kKgL39Wkc5H8DoRGtnLiyt2bgwhV0bWaMm1wVXotS2xtuTqH8EjTmde7zIVdvETDm4u4oOjQRt73fK8MZ9Z1Jj4YpE+CAZYh0PXzcWlY3I76d9IfH9lOfewafcd0Vv089IJHQPvkc20mqOHNI8wBzLN3TuobAcnau73A0i5Ke4JT0h8cmAjJaZIFuUDGTxokQepcyTxdisHAnf22qQ2Zbpi7gIE5Hy3AunTGfwVc2nnONU61KAgY2qZOwJ9v85raOaPWKBGoZsV4qIfPZM4g60oCNGydjzISEPfwXOJQdMFd3XguGkHTL3BO6ciCaFd+FUmhnzfzBBQQD+gmAjgAoo12o+REsVzfavuN1LYQ6YPF0RaKFd9k8V4Oo3DrUTjB2ISowPfKBcFSWCWyYAM3X+KZlt/QIKYbzDBNk1J4+FXIuX7IHLd35JzUrjEWr0TTYrmnF4vLQCm9NA5LRae8lhTudM+b5+Kl1F/PrbVTLI9uEEpKEIJsqu7ohOgRYiCcn55iBO6KHx6JN0sout0tHogXAcOgLuCH6eL7Ya2skZM55xnH4VsxfLaE+v/3YrktMknijL1gmrWYA98R2h5UclyQm2IZ0RA88FUqY3HoXw8d4l34kvmua79Eit9s5WBpfwl1WZB1phGyWH4Em92OqB7I9HgczRn+oHrTOH6gPNClDOZ2P9XmCGvMak1zehNqNfyoen1cQLHXpKmK1SuwAMAzOlxA8YjBQzjm5MVgeO7JPk4PVi6Ria9exZBnAE8uWbgfVUJv8CIGiEdJAsjuvZ5iA2IZbqxEb6NKtx4kERahD0Mq3Cqf+2k9wTH9d/oAYyp/S6Q+7EAIWYZ7JZbwJqnkTyx5FPZ3JxenCkRAcog7IUBDD/bjjEHc0B1+uyAMXS8vJ3RdXsuAIdWjh8tJGNQJAigr3FHd9RoplYz8/2srhfwlret90RTYR0jRHt0ApBSRBAiHZifHxoBXkk7+iOp4plhF4PyQBZJ0Pg+PUaxILGWaFhUBQJlX1GJZwSMeto+VVJjMhqbcF3xwwcG9UVxEQuQglD2vn9JVWzDNG4YDPrFO7fEoPXj5R4twRHg2Xu7AD6IHxV3xSuq9KQth3oe61oEbfXoj8ADZKIV4iTrjHlkYvYImgz+dTggJ/T0WLdG7HmYJlMfAoFa1rl+LLcXj1AyQqPRgRfAtERB+Rf2nDe3y5wJhexn31jl97qfh1LUZa+2ekwMxyQhTpfYp4v72KooR70TPPmA7GYUpiOSKxEGkXTQe9TKWNSR/Oh70XEAfBNDAVPWBaW/PL+MRQXjwUiYHLqe20UeUKj79EvIgjKOPGkxwgDAzuFG7Wo1iyKuN2sRRLcHdixJ2TS17Fs1fs0grxJ44ZU8I24rYYjTUdBSIqO5GBfWIbKrhEfoXjkIsumvAwbSd/AeDqgeYQwcAPr3ojcTu7xPDBvGkDWAtYpF19OFB6i8pZXL7wM6prhq0a41SCcqrKfUAk7CyKXNKHkS02VuzGFnCrroTaRZ2HRq86771trSVvD6WS4INT/l5HRheHorM0WaRhqkRdYoOiwaLoRF1hlyUxV+Jr3VUVhTdroJu22Mg12GleWJZ/u23AoRwqvFoIiZ52WF6EgHktV1GqwmLIKaNbk6MwW0jLz+PhakScxlGSFbcUgV/w3DNeSTlZbmKFH+y6oC1cZNSs5wdERO0CRa+qNENhlBZgGTeEhL6hEm7z63Sm+46I8aM0t+vlNCZZkxDu5g/xcEpXYEGYNLGfKzGfl3dU09vRB1KD8ncpffPVF6Llx1JizCQk7k4o9tkQ+Qcavclc8JFTeXtl1DXLmN/1s19XlEIapkLTV/6cfo0DsrdXVTAS3vvijlr6VtRn4RkH6y8PSJft+Vc/didnBESFR8ZF8RA/TaCbnuDJ3WpZvXVmjg/H0GCjJIOKkv4zXy49tkL4X+QapnbHaLFq1rObL4zs6iLl1nxjETZhPV3UG5lzopejpVYpb6k14P99AMJ952+eR3vb71HZKqbZUKCTH6XqomMX8LHQ9mT4LSx1cyRW6DIy2qbqwfIxBW3wq9E2MZHkt0y1bK8J9YNcMpwnM6W2AjifmxKBHcadRB9pgxJf9m4wf91gskIV9tae3dxFixDqizSbwplKsN1xTBTxHN50Bo5WSfpBd9qiviBUV3K/89RxC05lvoPck6QOdgF5ZFqJPjY5g5v3Om6i3S4j9BpoldxjSKkmv3Ycv0l37DyC0LFqj8vIruFXoS3cP9RSEBFzQbQzlUvMBPaQIRfwXQLv4piCXn2YmcQ4oTPwFtZRzegH/NmlqBb/JNK/bwZDW9APWPmeU2LUjpKaniNFHhr5M9wgdMLuOF/Sal9PUPmcEuzcEm0mw6m/LCEozUulERXJ8Lr5S8UlZl11gKXhAaN4lnGLNWQ8+au6sXQ95CuKuCwACFuRPd6v6r0vT1scHGjilkiq3GBic2rj1yAcVE6BfgPBfATZWXB8675StEGgawVj9Y8ugF/BVHBz4p1J2eacmQcAUqM0xBskC1nQtjalsuKmOesvMZB6CElq1ycd0LruBRCkFFN7zNDZQ5tHCLQNuzz46AiYr8XhYymMuXJxX2wmy9Z15b/hyUds4fKpj7IWWrHTLSRkUGfquf61uZnpxmYKq9DbQOCyJfwlTiyjannatrRUUx+JuSlSOjUoJC4XD2dFENjfKsM7fbRK1aqPV7VXBUQ747kTM2Ta4JT+fhzcfXbgReR5Xv0DoZeH8VwZa9SNB93yjrQkXqQRcgLcUnwR/VcyRj9oAyNZleSyp0fqiArY+laGc/sPMnjgnP0wOwQGUFbysnlA3xWCG8KCprtqSCFV/gME1uRUw2+0CSLRViewuaXehBJ5Szno6mXa1x3Wkfid5yWNbRMiqWszgPJ8MkmPl+n2zNmjnqOI+jTfd4JEWx0j1lsCKUgg1x/P6dulmro/YED/S+QdpmEa3je5sCjsovvCDa0KfqVN0n7BBUPvAg3A10nmUdVQmLtqO9PkAXkuTroSry0PQ7t483JilHdF5EG4S2fwTG4OqQU242nXTRF+irR0bH7OVmLVtOACbPqlp5XQcuaIFjy7j6zyOL5T3oEzVC4xahG0mIZqKdW/SBt7J6iwaT3VWqi6rHBBadG7eKOV6MrFisls1Cslll0EbhLPs57Z8rNz5I/pT6dKKdZgdPX02O5pJT3ExIXyK5AeACd+xF9UoJr/J353Od+g6kbGgB73OWrwxYh5hIG9yr9OKk6C87aXOeXZCL7g9D0uk7iwc0Cz3N+nXpK1odyMPAwyDYndkW9Oklz/bN8GhsMUlbRfHM5HzUX+6ZVrzproqn6kbnUQL+ppwgSLObHI8Wcdq9kVw/8uxy0LbvDGjgQCsOrh5hcPMwtkvhhRkNw4y60pYmq+c+ySE3uvQOiuOEqjO0yrDx0WCRp09zFsPq4nAQgOmoGn3NEueLwpYnMlr6VYG4Yc8lNH4F7S2LX5ooJmmvaZKPAEScQ/OHyb4evqAtg2C/ncX2qiX4ieraaeh1bIG5FHSmImzG18NMbJwnjtg4RTqDqwRGa/dp05nKwbWTMTFtGHJM6SOoUGgGgHHnB7RKuBswl6qC1XvSIw8JfuOP2ntgBi5e76dZs4uX6kn9cRTwZBIDOcE15UdQMVTsxJgkpOEy3zYU8lA2OJ/n1n1XvqnGiIkR2xBs1+wam5Hhwkidi0eJwROZIjlrjlAm73EOwdX7OFzmVxc/kC5+5sZzkhDkwn+zbqTltdrDYub3hjEVfvPIqQ542DOfrqCB1AXPVrGAPU7lq7w2e5Csjs5KmXR1ylizUDqnw6tfJETzXHQAMU2uHjQbySPzXXXEaf9A96P240nPsJJbuqkjjQ3J8om8uNaTrwBKfGiv9PcZrtVley1p2MnFsvlxDrLYZmdXqRQX5jV8JLD500X66d/iL5Mp8mU9Zu+AZLLBKf4YVlaXlckV+5SqXpwcWJiyrtmq9jt7xafcJy1wyCL2NJsTtQjYgIiYeFajTBjvXBYb9PHaTAjUhTqlsRfcJWG+0k2/RcHRfea/Wo54VmP6P5qZu1dgPHOW3v386mwbNCODXau/1Y9D2GDyZGLkEyd7IkanS68i8WmOizNq+5rfso5gnWJkWgVHpHvnjxHmokioClkLDDddDUzqvBrw2VIz1RceSsOsuWqsEPysDPNyKLs6I0ymx+ONpnS9QmrmFS9DrJCceyFraYL2t2TDkylluWQvrEfC6HzPpBsVCNn57ihF4n2cdtPFK5jjujZKGGk6gfH2iKIiEcgqeHz6XC8r7U6dPJwUaXE3gkh9ajxuimo8fsdPefwipZE93f5GVph7XjU+RgUVllY5TDo/0V+Ai4OrLyV/9OwnpED/ujmhA3GZFv5+Dx82YVkign4Z1czkdEqgRNPmP0P0Nbe4SUISrzYlBiPMOiX+uhxMN8MvaQkghcI3xeS9ZOy66n86IgggglJ8vTy3bec/Qs+zmTT3kcT3QfPXnAvTBzlZhANPuN+JZjiWBoc2p1nl7EsbIFnfs/VPP/HWO8DtPs7BhHZ5V2uypFw/aUHZomovE1rGv/TreNCD1Htnq+sPVVTtk5ACrZvM+zMcYaRaRM0XghU6ZdtwLikjXiW6Q2ceM105SFR7N8flOicKAhdfYQLWSRMaqBWaSDToFuHJ/SGB1WTd/iCYV3riU8psG+17kiMFT4UsaBCcB4RC5nB/no+2zhW1UdNzEeOwGSrsf/ftJuP5xeRXG1AzAnO7t2aTFZKzVCF59jWKJbRBc5A0uZ6+qAWCdMsw3nVOLSVJUrf9YgyA/24u7GU+nCYloH/HGzxBayQrzQjlsSZYuCnkE5Wco2wl0w6lmYaq2pwwg4V2NWbBEqdJIbUJlHRRfgUz4crqQFkhEuHup7cItI+wv48cHbYDltAjqjVjUZM/4bWw8scwCdm1MtXcP8s7ahkRBx1f5C9oYMTQ/AWiOJO1zH/CZN9gRbKRRV0wlQ6zzbOmjZ3ZA0MJ9g0o6AG43Y4u5+at7nRd7mF11XQWBQeFxzPO3SFKpOfhN2RBW2dHio4WzOyOSta4xG4MEZAMYbaK1fKHfRzzmbmhxHtIelNCHR+OfO4H+XW9EfwdFNP3z3cuPtUOW+hY5LBOQqcP8k8frsZxtXrZhbXVQr4v4Ygoz6HkG9ZLsz4p7V8mR0QX+Wfp8hoOuprywUKMSVbVzH9qKfbtwhxzVN+z55Oix0nGnxolJgvXA3QflFkebusw/EKBBc9syh9uvLHV0Lhgvb8v0Kk6Su6wDJGOIQtxPlJouf8VFRhLfotRsFd1lHCYwE3UdumdzqwyBqSI0p43nAWF8bxfMH3xb3S/4OHkbF6SjfZ48njsdqU3wSavDu8tHvzkA+u2VRdgxetlkyD2FU/uyN7NhloImHO+aUYnEXOuy7xS4jUP3UeLegosnUM7XiibsjKOjjhBTRAqUR/H9TkzDtQ/R0nqlf4ZXan6WCTWoMMXl/IQpMrjlfQcVo4sUbZtEOdpE//mz/DAlnW1f3ZxuU7NgJ1dbGEmMsl4ubzA7Z7OPGqHyHbdkoUL5SaEIT3e/3MpS1z8suYWDlse9kX5aa1FImlRnm62/8JPOT/z/n4nlnUSiP2trwx6Oth41iK4sz6bQQl3vC9gIAacQ0an1cJpd0H/GTvKSbEJiP2fobVXmza82lGpqqWOcw+SYwOFJstXnM2zAANLtiE81QrMI0gUVa0aEbjOOhjnrOHteqcKc3003lZka4U7y6D802TAghJnecGkiPrtzR+O8Vb05L+gDOU7bxf57HmwXjvKKzdy3KX+8LvZihgUwxaAbS2fyEALkPcAFm4SNN4jRMOStnuCIfZO7DsHmSWf7biw3l9BJUiodTtHFMzUHIgwh9yDyGqWPN/YRnGXjHwC17zRtxc4x5j4q9/20MI1fV6EJCeg9BNDV2MqZNxtl/ZrQqyiizRJo94a/fOaR2GPMQD0Kc1v0c8FDyg8yyPrYso/6C6opRNtaoZojuKyc1Y0IKi1ofo33W8SRWSxSUQNgZk1N/3h8707+1oc0SA9iun5oH9oho1m6+v/ZegNwvW/tMvnPTyMTXvt2Qi8ezNVIQTq8Nw0/V7hUTtSKwUfxfITjb+AEpxV8J/g0F+ZrzdpZqoZzQaYAVuE22e9vdicOH3mG8QNbDy3cvsDkZ4PsBo04to1ey2bQqBcotGz+Jd3wU8OBI/kKcYOdKXIvCSTHKundvQH50yH5oTrsOBwRKIvMVP9Wd9bFuXfWY09j4gbwWzhzrlE+yfn8J90Q1QQU33Tq3aA9mnxla9cv4VISzhjHAir7KHGYhGq6YVX4IcMlBlS6mhPhbwLnbUpuDZ0yAqkmdK8Z+qLdtdDSoXCFlrxz52AFAQ71eP/UZ0CZZ9F3MmLVdY0qxq2bo9tkb4fdhLNslLlcTpW1/FUBTpIBB1XRCKW/lYKIu2e2J/QLQmYoUjtA02PgbkLSlpFPy+l4AqhO51IOCFY/ZM5tD51+7x143jqUTh2OGHT97ov5weudQPcLf6D/e5venLSOM2ns8YQdn63fhEoUvrHJX/UYiwAvPoDenGYroFVLFjGVcGHxER106mDEd6gVsS+pebm8lErlvEYZdIp0xYAPThB3nDfhqznsDm7rFM8LP+YnaiyLoVSMFukTFNOptmpZgmi8odGFPcZrOeCZyivqN/0JzKO4Gb/v23mqyR29ml6nOT7LFAkcVs/CmaiUx3lgdafdbPLe9EUblg01VHKrwsmdFoxXFPSUpMFNlU09zjfNaJc/sIqXRs37itI0hzgjbSh5YFD0dMr3Ys7ACZtmALyQTkPVTFlq6bt57fqs2AALswLk0zWzbtgySJZqDnUso4re9RBnURqTshOB7SWdj+rr3taIGcuOisbCVLQLQNtZEWCwtVIi7Xm5hqyeoZ47t+wJZSCFaSzm+gKUKsdk5b7WGqzUwPefbTCnK58eCDAhue9lNkoLLOOxJDKmF7smum+14Ru+hf2VrYHtQrzMenTfPgkl8CmCq8NiU5Oqxmye7GxmbpuO+/CD3+/IQCsnwYaaWR3yMB1GVQj1OfLwmq5E2nK7VxUDDuOKxkLAiR+dU7eNr6UkwC3b7Z+tfzE4gzTPXe/CdeVo2GHNCKo5Zdnz7hMc1/xdQfxOpbpdugA/1IKun0JUoEOnsFzvgbkCGdYCPLZbPip9QJfURWR4RH9xAhMMOsCmYo3z+EQX4ymmQBtBsubCvm/8bvsc3JfzGhABQQJmCUq94zHaAbrrrXLX745E11SmH2MVOlOmZOY5FJ/1JHHE7y3rw7OSVkDLW7/TnaYp9UPKHoUQCv3hcKsdNUELUFR5sWKeLNa5R8CqY/qbPOxsH447czzpIRCGQW81iWc/6SqqzdzGQEc5jP8cHzE+WlN2V+JP9tV0K2HGeGJQ0GV2ILQD+x3eIJq7s5DOQDvpr3UMO3ZrcsBeh5ey8k6fC+VbzS4u+FHlIC4jjnaSKYYOkPJAjNEIWpl5xIYMcKOES/hfaUsw8F153eruGa7R6kapzKF/mPOCmIuLoz5/jfvMj1FiBH2SdgNVmjjsF86wE1pGVii2PfARfCaxo5DAjfvBSgJBhKzUf5KRZLktI2XZM511bpIr92ez+bINJAfHr/Gzz3doSgDOlBNVhgyBb9K1eAoeoQf2l4RNIOxn1WfouXrlhaBhOIK6IbbKBegPKRWgJqsCA0wajVl0L/vps0J9Q4X2S3v905aCxgGGQ2/qUevS1d4wYyKEYS6lbus89B4Z3X/Je4Cq/uz5lSAKLqRukNblUJ5u2r1uGpqZJplkd4fz54yDq9QVH50MaJBscuEjWPbBET7zA76znEoQpvLrpCmUMpznIuo2GbrHJUr49lmj8z9K8EbrWbqxzsvuz3XdqAbnTQDr9j+mpxYJWEyUmGNP+xEIr1Uer4nJXJrFM49aLaIPronYVprhzjI1eJlbgs02eeEif5k3BuR44ngBhG9AbdW1ELWx9HzFOwX0HbDfogIzAFMCfPx2Ec/kEOFqvKHtYCyYDMeVoRg96lxEoxuSyNhukZCEG/wMkWL10zGyKbu5dnYyv5NNO6VsMWoFtGWWEV5okCZNk1msRsK+ap480Xq1O+FfS4iqDFVXsW+Ui0x8e4ra2g6TRzrql5MosE7u9wb8Zr3OlOAcjylR4q6bdKXPIIuqPd3/4HF1nOACiR0ae+3ciGZh0+Ph7i5mJgPG+USM8lapwn2iUahzOO93HTgWZW7/GcCY5sO9/Rxobic+cVSE4JqHk5dG3UQvQ8vQFBnWPBtZL4k5nBTK4LQVjXif6yW/BRz2OKtailpklm8e5WyT/gCVgV7ZicauP/Gp1fw7CImq51UezJJpIUKs1Ba41soNlq26EdnF/SVBVnKUv9P99N46Cx8W49+G5T+6B3GveQgOxvuALglIXuXVDZppByUWVVFmTMqHCx/BkYQC0t4AHP+ZZUlK7H5zobE/frjV5itVg3wrOmLBMz+LA7zt8TJ+pTLoDex0vJ0KlDVhTqUElpSWeOz4zXhnBLxXLkiSHi4tTbj/cFQohUj/wL+H2TYWWiKne/D9+z+ka1UylQHVymsXwKHQS/cKY3NWK744h8AM5HsGlF05AGwxth4jaBFWV9Akdme2iZ2a1W0wM1MITEN4H6wl3utBCCzJvk9emMs8aA3KIARY40KUW3yl2lyvEa5rZtGx5szY5fR+qNf584tnLtz8uvtcdI70DjOxNZD3bw8e1xYzK+KzUgk6Pk0Gg0ZM+4a43WURxgPehrKRPuCrapcDcI4I/npUlTCTGxUaJ1orAJ8+Di5sjyvh5ZEa0a53XI1iScDri/Ih+wq9GhGL+W1AbjI5ePX90oFSZtZoRqBYd+xIKkdRpdN927zhvCeXKMKgnaeC6c3IeV7yZ3y4D1H/pLBxTxchl/vUad86AG6ogvW2GyQ0K4ld9bbcEzNpgcQjMtsMwK0EgG3neybdO1IkAP+Wu56ARxE16TeHAcWzqnyOrnIlogBTr/2rqXjxo+vVRDa2camyuZKntsmtCbZAlzftgfF54SYgkva7PYUiguPFtLu2LubxL2RGHMLYOORH92obq1Xitnihwei3dnDGGb1FGv3rZMKZw3uobUecWC0Ae0O/hCs1p8vEjEbQ5BDK2HKrTY0a47tEF/hW1HfRreS2GkPoe7Y/uwv3Iyr5/EQtxtd+IpfQrfgKEopt/QNR5irYq0kqDzoumxWaDsOsmm3AUJeINKlX0MHi7SGOmhyAMHXdJSJ/vPRQgyjMW9FODQuMi2hkiBVwfTGCEhvU8Bv7vi1F/PJW29wnxi4ok13ysXokU1d87xmNgwYGaU01Onjkfe8uWzCFvuZOaTPcHORW6Sy/hGxpUd3ETlg2OcvZ++JkxLJ9jWTDquQzxQAXlPw4cCb+cDVpRVd1jKquB9y4an33fxNj5T+rpZmMYIC+01Eg8qq6QAfUBMflzqKbkeAnIW9s1JH9Hko7MZkk0ZPTZUXLQkV38BN4ArTqlzlonGAmXEEXqKDl5awMt99D/eQxce/a7G55ra0cBocpjnp/r5wZOzRKAi0mNH/9dRGXRRy/NJJFuF5DVRwVGiKn/YZ5zSh/MtNs1UjCLgrN+ONztqW5SBxXwQlofrB/V1aKkaXmEnb5r/vNTbBiTzEgPN+7d7jK8zZ/mCVQcxIqfLQpfFuwmewIyVA1N/bRpqpequk5SB9nnk476yJj+bNTLIyE0xjE2eOD8eakvwJXMQzWUuk45PvRdm4Gcdnwo1MwOXro6h0zKLD0MBBI8WPs2U5c3JS+OmiVvloh1ZPrNuAtwGec6JDVBxgrXJElu32c5+ugt8Hemylx79im1i1IyisvhwKhsEAeiUhs65T9RJtFU47b+M4Y6KbyKJkY+oJWi4RBLlRTdjbEFiMrCQivUBN58SZBpEzlc8Sni0idu58L1EfR0cCCUInRffnhIOBrezrzz4DHY+FuRg3o/WxgZDETxOhUkAkr5JlbiNHRBOQRihzeHfyF3FKe7tTEKcctrwzLSRVYxFgwy1guKrt9goKPY73BtnLtDiQRy92tB5eWAvWfePDLqoiR+zLMx+TMMIKqebeqla/v3QMgcOuZjCjuBW8cD37rHwjW6laIZaUpupu7zV5P8JrXyD6iZseLd+krOyWg2qL1H98aLPS/C5WrvX50cFDgbdRrvQiDaHemsVSxGxhGTFw4Ffn0Wd6dhitbxwbj81ByH3YQh2+qTGHJwdCO4T16vMCQFbmAtzJZJ162ohGNuPj3R4fWVb/0EVZ+/N9HjR9Jif36Ijm8fcAI104xrnTY61sf7zEhap6cYCBrebKKWe2QoRroz0rOu8R8zCZpGv9IiZQjaSgIv67Xkc6k5OqDLL3T+G8tHhgxu0XkoLhUDOuh3h837ETT69NWcy4/DNDshhmiakHUoMEa1ttRsL9oHozeQo7JlA3LpestKsgJV/nE8U5/mtAKNln/Hb4DfPCl5riHtxImMkEhMACg8VOlUCJT3pHe+xKog0qtGBZTn2pfCLOuVthZRYB6rNpnFAKv60bD4OBxVrtsnV8mT+p1GrJ5GAWV0CB2i3TEl2urpHLTQRI8czvxETPlk9As1IEKu0a9iRztDfWgNtd6R1HenG+yPetpeFmVL1wnzZK8wjA/tlWk1/CcAsFFEbJUAS95Zsdwjttrr5wVFra7rqaQ9E9WIrNqYtJkwVquzCXNdQo6cgn73PZ9xIeUql1IuNpvLFEF4AlXICs0YBZ/EdBDJo7y26nAh/hJ/oimkoyrhiIm84+flFCoXoLiDML8lmyTdTYY1Etz8beZ/0+aNHXdK1tZ2Ph4Dyzz/G7puWKhi5OAYiEFcb7DhO1Lh6m6/hQov2lXmOtgZ4xNaAP0RqlhoiV2fjVYPADe3xanWEEyNCFzncvf5h4HyjD9e6El/DgXlK+F6LdWyAFfihOqahEeSk4QMPotoZLP5Qti+bM4CjF0KNVccDzfXVUE6MbFjo6r3S6Oj/QG2hAqFph2Qunak3rhuNdSD1Oo/piOYvHuCcCUxwRDR2Ydla1Jpz+OkHeMmhnPJwHuWUp/jUVO6xohqnFKgIMk3suTT5/SjV51+8sXqnmwhPtcDKQf9A3b4q0grd8UwO9hZoDnRVgPFTi3yyB/TppI8QY0P0oxrntvBkXd33nomWvrA706wyvC5RHOtSJCWsknGGLRxlAoFNuBHVePTCfltwYA0o2XguLuvrCWPlu4Moc1uDb5Qy8T+6IRIK4hcq92hbpUdrf7xsXsoaOgifOtHO+jcVPEgdNWBN6d9cLD+Nx33VxnCnCIM6I1TNyKs5ebueXeAxGBtQC82BqIotREktVcKepkDZkoNnEXoZU5nWwe1AyO7a9I/2q67Rc9oJ4/dE8TRodA2iuduw6hxmXFhpZBU/xH5lNemV0r/BGMSq3+ysIf90PsaY3V1Fyu6JSgg+hhgiQuNWr2Bs1eATPrrxNAigK1NhF2/hkK2ulUvb4KffDHGU96f1xaF5wjKJvefLtrQOXJ+YUYPZz3+kkLkvPUNF7quNPEjNwjo4nWhz6irBrjfos5D6VT6AedYWm1hDTFF7LOKFy3U/uVXwpmy0q9Dp/BfwpSlM4OVoapawbZHS9AGqjiTPIilYApZy8GN07z9EwaUjTPEbWm54rnV+PLu7GhqtIwqtk+9m4BaCT2jjsgEUq835HgewzM9tevhURDi8XQhHiE+uNu9jztY03XjMjQkT6Q1kHpFE3Mns4OCOveX+qHMVByHuBOeA9Txn0OQ1IqRj1J8auaRBHmA7LeltzK8XPiQof1sReHdWOL9sMwBvnMEVMGSn56I6c+1laYxB5CIUdtBpj8VL1Vot4TwFhelCKW+NiJT3nxstiddTCsTyp7AU3s7V2flBSJNvYuwRqLwlUKSPw0G085x1UOF5dlG6O9bnVQkAnFs733p5UCB57SI0IYWvkOzYGpw4Os6xqIL2Vn+TfGkmufdzeNBc3wCL6Nm7qlXkARtoW2l6fj5SLBKgzQGF+S9it3sohZVvsa3XLodih/o187r4MNPgn/weNfrcFvDWJj5gjIwoceGyt39zH2sjxXwpuqcc3LqvyYd+1NN5YV0kC1wr+0DgskqimqjgQ2YfENRESeUSukWDtJBaiCI2qK5a6UiU2VQgggByDmfUvNFjRIhT9SCtTMR5xFwbUt6rf6+9JPgh4VFrHrSHdcQTho6GSPwmVPmv80WpuJHJ4CIwLz2F22eAGJjy8N1pEy7a/OCTDYcFBHahBdW+/cMNccQ/spMdft2CPCKSu42Nwr0iH1NCjHm7zDIqiir9RdjKRXh+I4b5656zKPtdeuDyg+UIc9uD+iY0RzAZUGAecqGDqh4/T+f3Cy8yjgOJgiCmr8fGCjVYSP+ST50t0H59AoSX/Wlq0d8MIqN5VgF0xHKdQaJRC1uRttpn0GOQr0LoSDzGuHG3Bz3h/OcTd6rVi3SnEbNQHVc1AxzGnWnUn9O7CFdxASOixqLIU/YeYKjR3GykgtQk7QrnqRLeBog1rSGRVBpLmT5/dK5upPytyDTSgCaL/JA6IcGMY+a3WATuIOGSEpC+pxqqLS+w8sYxEbGd+9+441axjH9QJNCEM6mkXtCjILCu78DdyIf1RdowjmCC64n9WnVP2Wb9BeaJXdHtsFR4a8tWWFtA7zWT+KUCo3hkbJGIetQ0Wdmo9BeapDQj+Zt97uh0YO4od4ySvLgeqTMtJxPJksAUd22QLWzegHqjwapuYDiTsYNRu8Q/mdP6xyPCQ0D5jYxOWhfpr8ngGEV159s6jvlb0wIn8Jn9DFSGDAntzPufxd1IwQPmxzVIOWHYXPXWg0chcKj0k3n7CA7WPA2CmyxQnRje/0AW0awW1nPlGTGvW9cRygTPEuOPJOVykOHRujkn/Dx6rXsE8RE99qX0qOl7oNtT9o+u/xADb3rjUjVPxmAQsrUHQNe7kpExLNCUEZFifmwUdW6z/UB8Qw08K5AhLBnWtKGD2hS5+Y2buNKLmtvgmxy+QEP/1BjbImowcz1Jh0Kf2ys+Z7DcWxaUIefUXRZCU39jTTD3X6HnbGUE/AlIjHkI2A2NzyrRDXYakr1HfTmR4sdCq8uijqtnQWxlR8kWPauGKV74imDf6WcQNTysburQTJPzIyjXHiN65ugKdUH2NoyjWY9jGMuTSoUudl8hQuTJ5mTZlMthXFIRRhsWoWhrxbmeYPFxjktHjCwBwCiTb83vl96qSUdDQ1RFpAb1te0fZJ6MVTa8hIyB7xaS3o86vCFt1+UyMif07faZdXmSbsOuiV0ANQOIIPa3aV2cVxxpxnZUCzXiEnYnrPTDLS5oOjviHeUZJ9cE2V4PK1Eia4LrUHj3uj7ep6V9YDkaFjwD94o8SiRWkyK04saID5UCJHrctZ2bCiYcjGgQbgKSmBz1Jl3rRmmsQAbWfDrKE08GgdwybLkLnYT9lBx2PNje9DdUXbDV171SKtCuZoZxnajT2Z6RbHCJfDUx0FfYPgnj02qiJZpJSPgmimsqIKvdjo5/S9A122I17aklvXgXyla/bk/qryydm8v5T6H79IB9vmbcIrn89JPqUHIoIocmBihdIbqHQ55IYn6fudd3XoOxb3zqXNkMJyveGw7GJEn49M47LNEnPSC2HyoFYdJv91xre1LC/kLrsdBrUHgW+fGhHJ/uSdQfpiwvnZbC7wIP5kajO8L+e+UB9V9J/uhTiXL6RiH0Me7AWDGIWYTOyqrOg0IGUAnLW4Qlnsk3Wxs9GLqEaXmNuC5rP7HJQNC+Md+N8iB5HevSO4NtWSdGuQMZmHZnVLoQjHUqtDbegMgzxAuYfNVebQVTRIDpoQeaS60Rj/h7bq/oqRD8XT3+I4d6RLF9gSUQ1530y7vCR1vVtfl0DAVeRaq+VsquwocxPuHBOJ8L/MKp9PQ/t8zrX8bB41urQ0zAiV2aggMqdk0ZmlgyJkzcLApKiVL/0zRhcQUE9+2dedkd0rgJNIFppnvr2jIHvOstZ4hek+zEsQvnSDQD6S4DNQ5Hq609WewZdXs05GAa08bzVbbuUsBQGWtwINZg7MzICQqiZ/vJe0BjQHdz01K5xHOfdCFpVRA1XduML43MQLUYwU2Bb5kSAvSCL2DxXuLkwNvM7ppaO+t5rfaS6tobvuoUSzkjU/9bgzzzjb9BC5sLugblRuHOej4QrydgYvmLIVwwZmJ2MmJz3vb5NVnrmB2J6LxObztY3hM/mDQWVU2V4NeivEz4Dhn2OrjHIjHfjFcKNVMZU6SWxbyDCzg7ocqdu1GIKGh2ZvCpFZ+dybB/0XvTAdToOOK07sny+EUOtD6UMdvFZeggYcDEYnxyhq01VXDCa3wKVCQIUh8qPDZx1pgoWG9x1CwJcCTGVLmIXJhmVlbLmiI8iW0ejqhgbMhRSKyXMlfbGKT9R7+am2yb/WLB1p/qaVTK6QwnSk4crDgpucQtHbL7XlYtkLKilKH2wdGS5nvoDRXxbe8uDb1FkjqvqI9PGZu1MtKtgTu9zzzwZmZRswd5toGeEyihcXJfcc8ygh0a1GGeThRRh6w2i8bAGNbDtD+8zknSvZIlUBYLqTfSGRQGvEnl3RXZvzGPnw/qVKZZ0poEbDovdca4+6LgPxY8fAXJEStuoesayWGGNgxAYHUhOdGAO72FJHjNKQh8Aar+KYZjknBD6YOwdhYgU9HvvATUKZ1U0Ac0/dQOI+rhyXEWK/8zB0tM1oLtdVOny4F1GHPsv786xpPaeqFtTWJ4Gf+eUH9pZ0kymxVUYryJB5JOFHFCV0x2qJgd9vEEJZPdW3Nj36m5fKUNEib6ZW6DQcI20cOJRKFa3pEFtqwdyFIywUHqngBOSWflJrIBJ2Mp9ZHRbkouv4rSrFGtwbExJ2CQpBPfKK9ra0aqPC7dap/1WZv3hX31ft6aOiD+dBKaE8IDeOV9VINOl6dYD5bpskdQggnmDEWcPxHWUgl6jGKDfyRPCmxRVEJwRe5Lgu5Nj3z2tIXIoeDVe6bnJsxSY9KRJZUu0ErZoBMUi5zfo2SHUMw3Ak3ey9UDywqxak+O8zJlaX14f92PgZtMULZUb6berTE9sUqNeWpT+kxfaIspbbeP7ZRQ70SV7EF6270zfpLW6kQDaK5e80qfEvTqyerDxTk0pt0Kez+GgdWDG50ERI1EJib0e/Nuas/5G5P/cZzCeHipemUjoaKE/0Y3RljR33cuJ5MKMDt8eZbqQwhILPSVlO9qzrdmZVHstZSNlUw9CdgpuoLFLmEs4LYmoQi7O3F0dGf3nGiNHZr2Gv979g+zZ1iWOLhj/H0/2AszmwWjXTKtEWI+uBJoM91ewjBR2RPaP7mkhB2ZlgP3Qj/fESUAotn2WBD/3MzHRRe/liT3ubos4RPTDk4715nUgNw2qUzY/cLN4TCiuyQj+QsxzZS0r3MPDI/QUSIyUaQGGq5FYjJSMezgqaD9n3tPastIPqTD42b/2SSSNjm2+xWw2ITBuQtY5jZbw/AO+3/dNYdzfFDCskNFAcoSkOJ1ccU2UN+74zN4RHRfcaL0hSraRTGII0BCtcWHKtBsL1C2I7szw7rnJQSgJUav1nxU0GrLl+QuRd2OkIS/juHey9DPVVKGP7zNWSK1w9AUomc2xB0PzE9PzmzjDTmbuIG2+WNtW478EQ5DzixTstMLJ0LrrHi4aKC0Ex+iM5c6YHPF+4sn3s0qtvvGFnN78AzhRq46hoyFMQnWNJN8ENrAxFJWA2FeIBgEPju/kue66Jl4HV69/eth/0XMlzoEF27/jLb6jCBcsCXyYKLipOONG4Z3b7KI9g8Bcgm8hM46d046BHCc22lp6xftGqOGEvElsHIH92Sg0FXYaRcllwoSgcBNXCaDItHUim7inEd7dgPiNF7Rz2l3g1y2781S2jerd4vWLISSwk8WPBPPhDcjw+zZhY7G5iQrWNEJEnL26Z3ifOCySfCIFjlgQejJemnxm5ROJcZnzilknsjwiCbnbZLDpXq/Un/RsCDQN+LQUjxLskhdhCKap8UW4ei6JzNHU+PaDM6bWuR6tLign0qAoncw1F8E5lmosn8ohirTAHlm7sWuJmEH4zud1lwe428Q9pWmOWp2gMSgV/DXreiFMMa55MkrGSYRYZVyJMl1i10sfgAo+g8WCkgGnEbormTd/uiR45eVEJ862/MwldYz8K82KCGG6gCym/bAg4ATVyfZ3+RQP+DAMMmS5B0HSHI+zmVs+USXhrziwmGZAKhM3SuAC2VOF9EZnZIn2XZ8B6uNwzvji+i9pNpmbhOzRGh9UlQ6nz4nixI9lz1bEnsqgn5u5xxeE/s2lXUHqgtFG3gpEecu4AoD0XDnokAHAjhYSg2QZQ4ARWxh7QNW8fGoTQXIjz6fPap34RAUsLcqN948iFLpNFt+KfOpQwGsaRODRzIdHUxzpB0Z0icrXVstiFMXww0y6jtnuvk7/VF9ccPa820OxRrg2sJS4dkZWiPMQpKHLobvpGfntU2+2ZsKQQ+dMqVL4DZdB6Som+a7adhuBLpN24GzfW7ccEkzyuz037r1ru2/zH8EQYb7WAL0NyuIUqd2QXqCjmfbwWM5L5A1CJrsS7jHFVkwAVt/qM9tPw7paN5igfg7nLZxtA8v+DmUk1F5DwYO1hzx6pBne3DKRMEVBQaF7tuOnd4USc9q2bxnKRhiUqocacdSpU3Yxyain0KdO2uBHD4LqeiX9QYkKOeDyXzcyX9WmFtN2oYM1agDybcg23mz2xvyq8uYxy4Tk7nd2iYavlY+PpAZH4VUAIaRKEzLOgO9bxeeoyXgVy8Q9ZULvzgcMxR75N98m04IEE2pZ+btmRc0rZ3DIuWT2KTluq1jz4eoJ9P6YX7TPjXrSR8MC8JQ3j93RkXdLP/Uk1E4X2H9IDpoqzXfOw17env7X6TPxtpt+8dIUA4RZ8r62r3c3RKNdDVKxfQmzk2TNQ/QsGGy8YBWHznZcsMShmIJ/ZHDr7gKDnma123X3NI03Iu9uUiKPFCwDwJW/XKPbT+ZtxT0iR+mYUxuThXep0E8Pz+K7/2rIyFtD3V7qC3Zw4h1YZ4g0grt2WVHxlVxnn07he8ArsRlcQmhyeWW2zDsVNBYRlJTJRMNcEp8qCmQxDPDLLynfOYcEyQAw67/QRiVEMuXYXH5uBpf7xihEWPYJi6vwV/dp2mStiBdjWKIjHg9ekh6oeZvV68Qwbe5D5AotEebhiOrUyfQs+tvUT6vTcUsZ/A8j3uSkmSwkeTZFKD0ZWiCs+MQTCj1ewSeYfInMY6RNuJmVWpCsaHX5seXRRf7UdiBIt9VCgdXJkQ68+Gk9/IjQJRALAIeyb0hX9WLCUuQJl/TW9iv9rwznFQJ4HM4gTfXTO9uUpD2CSJMfP3/xELvWTpfAeqgn3UFza0/wesXf5QR9scoKH2wlYCOE873+fpmIDxkSnrIXQwN0fVy2lxbQgSKZ3yQGJ3Q2qQ49BQcsIPoc1EUTpLFQAQxzmtwxwjra2S/lYGrcwBKraiUb53RWJnHAe1Iy6JBZe8e0zWeg8bZu88eSM4bd2vabZKrSIxmlhocr1qVnGtm7sCf9smEHAwh1MNrBNTL+h4B8cuTrz9H3IqwwP+esBA0KiECkd8n62aVsGooLv8DEYXT1iSIOYDAz0RqjGI1VCTw4sWrRMXv+7eehkrGbOhzNikrmkAKLq7TSs1g+qRn4QlfrsWsr5MeH6+DTZV1g4AYhikaxyV9+5ufJ1H2r3y4DnnRdH7PqL+q0VeHPuK2wfHoRFvvb0N4Lc4TeP7PXvS3C8ejaFKhy4hl4rKsbf8PG5MxMt40wINY518wGeEJCVUxPjTOY/IfloG/Yt7S1ggH18kU5m6cd4GILhj2mcm+JBt07zQ0tVaCG8Zx8XcLjZpvwTTctsvw+Ba04wOmRkEYcTOOg2rhu6TXnjQpB3BAXnbhrFqDL70WAWTYXjGqC7jBLMjsJwm20A438gscnpA42SOVVAq/o/SdtAUEt7yPUfFikayJ7qFibzmR23fcxnnOKmoOF8tfy86BSj2hCtR3/dgWkotyEoWah0VLw2AnAQtuAtaeEsUglmrlnN2wKFYxUEDZUkFVNummgAOLqpTUQ1ExGWd9EkreaEa7VJecPGFnwroc1LdQNuCm2z7FYiB353mIKgrtS1audYYSak+qYbQVjQinf8ILobCRDSb0e+Cy2TgyduCHht0IIKN2BDMa+NiEzgOjQ+Ez1ZQloRgjb5SxVJht05F5vyYJuifajXjjEs85FxU26w8zpp2d+DFgAeKeBoRCPfFqhbEV7fELrqfn+Jh+Z6yGLwZCgoCcaPlAdXhYvO96OUZeMJvloa21rqHyjDDtHKELLeM0Hoi1+TFn1lcgiZeQVy4B2uhmOf0ONOyTWF/rYUlCG81FHEyeM57qMsmYUMbfx2MRoveYPmulkdrkV3MXu6SxDUSTI9RCyyVnbvOEOKeEkpIpVhMDVLPClhUwL+22ZWZAu+jA9UPa0OHhRxASyOaZV3sYmY7mwKtZyi5emrTdafzO1VLatU9okl7ViM36ud9TuIW/aAMMk08AzJO1AhOQC7vtUu+UXY1rMsbSToARN3i38OTuOU5QpsZmF36JoEMrA+SD2hjRw/LqL9Op68FDzbRU6ZrGjfPZKoqfZD5S5DoHWGmPoBSBJRFIVXDTETDQtE653mgSb8hjbYJZ8+BoeX/MoC6OwwGKYaqRIjBvH4u4AFJuuMxadO4bGEbCfmmMbRz/0NIZBUzX6rBLHAljHPWdpRuu3K0Jjm1KG8qMOSbmnu/tdxW9t2Ht1MZo4EJCCRDp5M6He8ReuEvMOu8mUKJHg10JAwmQ8NobVMV7RznIU/FE8mqiPg8Z5Dw51E+be3+CLR8+GZxINDmie01vIV+7Icb9lAcdx5zf3NiMgfygVN+zLiYmRWc5IVjR+i8II7exWblqkiqrLmrw4JYWAjydoeoZegFI5ApQtgRF5LVLcmJG5sJNNrU9upDaqSfDTYCe7VWAKs+ZiGoJBnHIqFNWoSbxGv6XQwUWcKnz9NvGjDubtXqRcNLi75tZzqoXj1NtJPm02GSVxGzuJLIDlWypDzpHOEZ02q3fJlFsdtzAYb81GSF3pOwWUKnNonTxA0vGFzA+uo/koMPciLTnMTzZunkIqrJVSrB+kQV5rjfeNu58cBhqoDasBkBRM1CjykUF90YnKWH6DNIE0mfeonAnUP+aFACYeN+BaVwtlIAn3K2mAljeT2zE8K0Q0PmpBDDHz4qrr4usMbl+kyBf2mf3ngC28Zs1kMfedbSTIHwOELtoxl9JPmc7mazdUxJcxvRU6iduCHfgcLnbe01CObQUorermCXKCZQQAcc5IPMwgKYAfaDq12GxzfrUBqO7BKIXCUMX+BANp+eP/6ip2wr5tVTSWudHJNPKCIGBHCKg67glSH1tqrqsZrofSdjLu5iFQ1UrlDgg9lM09wAgI3PDbDsJmcPMp3zrnbLFm4kag7X8OAvge3Ot3/znhkeP7kCo5OdOOPTWxBXl8fylXVvjv7OpEggbVZArXiM3dc5mmWI0eyCGnLVTX2bLKs8uNB7/yfmtOp6Y0aNnMoVjjGHLCSH3SC2I3YvztaVmAQCQBfaLX/5JWohxh6Q/3XPwK846pBVy/LlJS2gbmPDDWlSoZK4YSd/ve39idO9c3W4WUx5Ou4rPZ3RlFX9PyVp4YpEuZJ/Tis6rECsPCPA4JYoxFOgX37pyZcyNd6PQ5+dFtYh3XgDFX8d8RFUzkOgvWY73hpX9EBHXYXUcBQxOw6cEFHPgvWpSK1NN08ZJRfmntsNul7fQPETaftpwASWM3uG1QARtq6Sm7LSRWas3/m85DGEBQHiK5vyJiItyg82dzNpVFmeIIrGbheN3pLDpxzhSK/CwaDPdgYXKI6Un0PLctefK5j0/17mUkNlEZ4E9V1IDbZBal6U9xbb/3jdEN9FzjTWHrQaeOmwf+aqLTyQz1PVGD8EoKoSAJVJ5JT05v1qvQthKeJ5qIHEdSmk8iuTIQnTllspRJUg3nm3jXNAyH7B1+K4ad0HiNp9ncLK4VkWCK0LvuijHLfYmM47DGlYl21vbMKp20wAqKtXmpv3VyBW6ML46NNGW6E9BXlGZjnw0vzwVtWhr8VL4o6SQfvZZVF6r3GHntUXf+n2/tLJ1AYgsmcSaCLXZiAgVP3S58Mcwh6YBFmXe+oKMonUITS7K1/s+PXfIbfPIIzDKgUmyfa8R2vtruhn5/9bC8Dk18ddU1xRfsM0cY+sI2RhZEyYoMOtx5WYxMQTd+6YxFsNsHdWH/pm9Q/0fUWbCpKKFtBx/uYM8bTaf+rZJvVLLGi3y8P5UolHYOfrIWD3FEEj6z5aEPsIr3UXb3j/WaVAhlTtzILBSifgv3RWri4+Em6CdqOEYZjsGbP2NM1V6aMBpftxMJuPvuUKOlquIINgcflggmxtUWd6NJw+Ma5X3oIJhI/D4QxtXu4ebgFy/sa7kSFhNPGGf7W5QCXhRwPhyX5jIDd30diCxybpxdjcLaeq00uWhpDo2qwFK3y3/AT0OpuG9GgOWX/1KOt8Cwk3y1g+FfOiQgisaTTEmyFOqNUpep/6Y3NtNogg8dkI6hiwg7aSCNrW9f4ZyRwIxO/n1wcxExNpuH82YYt3obUDamocgDVki5D0FMfLOtV0Rc1YwQWLJvbtkvVKkgbuGSKhv3CSa21JvCEv0cBAuCMm0Q6EHeB9vWG/bNeLXS5DxBej79ZUVbmLkROf+x8Ogvol9MQLxkDp1MRBwJ27GJbrCbfNp7tjfRQel9tRpcj47aLvcJMU55JgAZDUwexw6NMU84M5N/wdqev/VaSFti0N40lXl34oJ179ZeN2K49/zndsaD04MWK5tleBN36wYfLWwfWqRsjFYzpoGCKOzf9or4gZAW3z4MhGwDQ9zOQvkPsj9kfVH1x7nrAVMCR0eLhdXMFgO9NqfHj3Jq3qoxlh8oo2pYAMZUGQ/GpkOfKAR0D4jtkZKwMVKGFz/BHfuAeP0PaIvstOtUbvHJhbEww4XU5Xey+px6rSIu9mWl5GP3TvtGlg0H5wP11LD81elw1VrXLhpC5Ki6XmhugoAhZwoBxptsMrJ3cWN1LgdkLjzQl6ZzsazeZEA7cFD0O9OfcyuO3cqG2ZdhXBvzpRLd0cFS0Mn0tQ+Gmry6fm0xWbrhWnskwOEFkYxpTWzm5grguUfhJ8rMHN4vykWIwI46K5PD6ro5G79gMhmjCzfd2OjY2q7MaqnrhaEsDiu4Qrlk/Rr5asXD03kztAfRvoLhczeaRYdG3glCrAgX37QcBxt5XqO373Hp0Pz08g27tIwgHX3vfrVM6hbbBP9nIrn2Qq5q/IlOL7VJnBa7ClnZlv7afvPdW2nFeUFh3TsFwt0mLo9Ko9bb+hOx9orqJaQxnOm6+T2T/3Y79Mbd/NO97txoS7MXsud3VgW45gfHWsS9dFKN2h3tXJjBu1gNaIoa9Di8bCwCR5zPc4JRHKE21JkPDYtw9AiiV0GRK3UtYsINsrCgcZDurRzzvQ35DriTHGVq/BWlUr1Xzab/hooqWgFmijlsPQDivuwUsMM3Mb+QOkgSoTKjEi7Eo+cYmtqvZPQAF3kUjY6etHEL3PGBfTuacWqispt0iwGUw3ZVnTUE1cxHgoes2NVJ+ZC7vY1I93YYYhZqESW2y4fQ21w5zE8C2MpcIG4n+DWzODBit7Hj5ZueTwuvBnHBmNkcIGJynKvH4I1U8rV02UBr/xf89tTTVcW8eeI2DmBQ7OqsZvn+CpNkbEtLrTzQhTcIXSwalJL++Yxiw276fAKFo9MPSVcS9uo/lhm5TgjU7laBYETNafByv6ld73zSDjHdPS7kbswJx9LoHcS15oBDLeQabB1a443hVjo9EIhOelwOSRgXqowxQOM45btKN+ws7MR7gvkNjEHuTE2xkT2fnU604c/J3wtRCd+lRXSJtvjwUwFxMcGNfsHQwZQBb/W/axWXxayqL31uLkdYSzvpHPcgisWjbFHuAvFH6AEknyI0R97wZtxVX0QYinmpKDTaJUwQAgat69AURWlCHHh3BYM2zF/ENaxbAZ07qbxrkC25tlwX7aieIiTccD4Vr3iNAivK3N2JQ+xTjEvTW3raz3wfosGr9y6GjqwXVI2S0zEL/g/v9iWhFMbvcSZxsJjg/XDWYgJByCmsiPcjN/eMm95JU6x8iYjfXQch/s5u8jkhyM+5tcf1ZtUzGNKb9DtlKyprPjolJhCp6l0kp7Ar/4IrpDUKUgFJhagWyJLTrC+1F1O2TJouI7XKkVW7vZJK7ZHsY8c4698Knvwhj3St8XcxzRJ8RxxSPPtHUsA7QidK++TXLnEwl0wqV4Nf3ZZlRtIitVrbr6qZjN0eK68Ut/iRHQADSah9bWd791W32enuhdLE7VdO05xqp8DPyRhLseN35RDIgSak+jHRqhSbC+rnwBxb/bL4fKLxYiripN/A++9cJtPleVFmcRDcGwtyA4ZIio70uBCXV0e599pJolAHB6CEiGMPIjjtjFjwDznkMcxPhQSagdd0yy3khJLJ9JutMJJ5DAaDSqrqef9l5oVHL5Yx7qb04c1xOVhkbRQW7NfJixa2sa+Ycy8eDMqK76vySAgL0eFGq6dj0gvMFTq313Q8bn3521yBJTBfHowGM5CTEgFz+KZ/A4RB7HpWY5Nqd6OHm3NL11f3Px8OBpM2WdmnHG0ItRQLQo7OZqbivSrmuJv+XBgbfR0idjiO10RTYyMWoF+DTo4TohMXyw4EN+kOsgnW22/hd6/Czmxsd5A7D4dwV0ftNmNHu0BRX/HV+cruAwPYRj4snbIoX+eNxIUaykpNdl2uuedHk2W9Gtc8NcxZLVuNiL6K6m2AwdXAi/B1AWbXaBP5sqxNJIM1NilJr8RwHQBDZETEArxGUiUkdkfj4Z2U4+482hCSsbDVWx2cZZwmDfT+M8edbctJsMlczI1mNclgYiLCH7XzD+k+t/aLyLugYViOCYlKR+3KHtULtF8QuQNCXrb0dLmcZYdW+07PmPeox4gkM6GWEKRJdYN7IdcgxhApTrB65a7bTH9s1Xxwc7hxiDMH2gZ9Iuzn0yivyi69TIGRzBTCd1Dwbdv2TFS90Re0eCLarPmZUl/oHTZLHyL9xFX6LzvhvOUyl6m2QCQqBPAA30v9obLLSmzp2s+MMEvYYu7pdz3VwSH7kBKPk6K/Cy+jo3gJRXe1BPynjSs+fJhc2O/olrNh/bCACgUAlWlYncSE2Ptrh8b1TewxxG8wkiubCEXFOMWtIyqspXZkui/vjIDyylwGmprEvvGp3zZZ+wFSIXJWDjWPyY4pNXGVi7m7LRCZ81k0tTLcJiBeBjFo399fqEi4Q+85zxyKm7avxTBlT30QU6Cau0PolAWZqULJBii7opCmzU2mrOvHDqn8rF71gsclUy1ZwncSoKQlvbYpjspKxoI202GbE3/reCOG+Cok9npZAGd8pC0/jzSoazE88rMdtJ3PVvu3+agFlyUWGWO7WUqIE/YE350MCMuCTL6fiSe6VL5M/5WOPrJt0JCpaRymuXj7E5nXfx5AhMgbzvV+u9t8afSMYQ7KsRXVJ4Kuy8HbFdjeAqi1NuafoRbhSGmG69dnqPw8BrKUEDx7YSiixE9iTDrsnTxzdmw8PHG4gC1sOFxnzvrdO1I/TtCx5xr8GxvnsN26bxs4wVflfjTNaMQaCNOduLvOma9nzs0EekiagnkwQgXoFd6DK5s0vgfYjb8vFJGFjlQJMH47nN5yvjZEERBQrawm1W0YqjdlrDzdNrVodzww5mYqTFWQn87Y8Ho33pWw8d1rqjyYV4iGyH/iy/2TDZiutzG9486h5C9YdQ9AbbEkfHInjm6KCETvbKFus/EactEOahs9Anid64ZLTj6aWz5HE1MuqYH+8K9hs8NbPo5cmZCF8U4wc+W57gp+0M3d2elnVQkMa6n7UZ3JA19JyKo/rD/g2+SifuPJdNWCvAtRtwFF9/72IZCP7DaXPIhoE1qB9Bu5oZ9HXw4vSHL4PmTCt4wse/kLIE8PrEwR6LB5Ed77bGShYOnDKcFGAri7AKXIwi0+mw/xAqirGCy2wflI1cxWR6qKiw4EplZHJ+HR/a4RQmcBgK/RVp/U0AX8ZZkbbHccnM2FL9mb3glPmQe8RxHHxmaX3ku6LCg6r/BFGWqZFif4H9dDfbcqGZTRWR9tHcgCR35D3j/2Y5drmAZqLGqxCl7ZO0m6xQgcdpv8CvPK7IolasU+79deGRYO0HDcmumNzKU/C9wK/K2RI6YlcDmtf9c5KLHvafS6J0+loGKB0Rmrzl7TjYx9nxJ6i8QKp4NVirdfqEfpXrGlZqu3DCa66kDkrHYhf47EHnfgmx0CnFs7VPTNQFXUZ8IKdfrmC7O3nC+YvnMO0QZLOgNOTM3NDth7llUY+ANWwPNdO8ynsk46x0quItk3VpqnOfbcB/OvlVscfw4nvNKa3EIJXIhz6SbBcHAP2tUGQ1H6GQOpw8hHalqX0aH4ckoDjCfwkKLu03nI9LaNXgctTdhOcxZypACuSQnzLecY4fYmitsrVfhL0uF4Lr+MrXL6hq+q20TBd01JlSNg7dFoiOv/9/AtzI4kRnJr16i8zy4gX7SJpAk132drXHLMerFnH0ebJA6o4LtUm98eM4LPWKVfp/fhrMKcXFcOAFmWyY/uErfYqIObK5fmtgTy72m55lgPReD4ZDEjfT4e0TpQKaX8rUZAm3htGtIlkeLo1UlzbzcTjrFDnIaklsHSG8FWoQooIHlWJ9pahdj3drioV4QJqQILt1RAG2e+oygdyJuwgMYMlFxHLb0N3ve1BlUrQppDNsvpdQx3SoLpz4Qo0eTszWl69dJ1aLH7lmWrv8LIqfNosskVt0vU1G3Phx5pyVQdjzM6UNwkxcxnBqq4akZFeXiYnZ1T/qK302aQFy4oT2hJKZCLVP4UdI/BelVcJAl2m+5mWyC5OTS2a1cU5o0eq4RrCrKDBcEmk82nCdaObOz7014D6/llhp3+WQMUGJYQ0sg8Qr28Dam5OkGiLgLU3sJuVHN6ns2flJHDqu7+XqIg2qxQhmEI5kvePxjREQTu+XIe+JXv3oTvdwb6GIHa2ta37D0sjXhQU+WsC/+2L5Khfy5RT6hcVCAigFkBYkmWygk3AF9rPydoHQrUdsNhQz/imA9I+SCdYLlq7X5ljyJhi6JPChMhy8QcGJy+YBksx3wDodh2toIzucc4pMQLj5pJSXhrCe0jB0yZSd/mGHL8QySrnZgfIoAPffBNLWbj8tcGsXC04FWAIbZUngZAKp23DFYDoqk27yuplG12yc8NH8OXLBhH5cQUawjzj7g1FOeRcdFV9UXtonrKqvRkb4GoxN4KASDyCiAL338KwT3gdiL5H1z0FYk6ohYYRU4odxj2Jhlc0awPHzyZDqwbKYsQDuCzTPzWIDaO7m4VFxF/x66iYKnc8aMqZUdcnfNxBMPRgDCgSSqYL5yDt5Vz3SwuC1tN6Bd6XeZj5km36oWaX/HC7aaxligYM4aFQvuo2fWbSev9rtYIoDU2AGSoelp274onJByuA9FifsC2ZuG+g5OEiMiUq3/vNxs2Jifr2ShodU9e8imp4jbze4A4Bh8K+ZIdZH/GoFTkBtq0WLw8FHaDUZIvWCmGHjeUFIi/OZKbnDt3ONpXUhbfFanPuwsezN4TM58nVaBQCE7vBnbm3GVWgP/IuDamNArhBpKxgG1ecE3w4r1mj8PoNE+C4wSgXflAl/Q48ue3Qrz9v+Ea3nfLH/QRW3gfhMPjJDPq0vJb/mpVRFrzzFhPAhxSq2s8y0WcHzqFKXPbsEtMmhIvdCNV1bZhx6eiZR6lPhWIlZ8FTg1tOn8DNBBpDu7Iie4cuekIqeP8M7t6aVJtI4w6nKJqtFS0Iid12+zSKgfuYnTm9wFZ/l3prCmVIGe8fhHlonbZcOSqYB3y3y3z8vWLZwKXkWJ0BrRs8a0P6+73cgoRP7xI3ksYk1a+hEewHjkfYJvVydAd9nM2TV1y4gqwKW3RbsLhRi3SQ9+SEFVF1kBYdOd/FGNnJTCDXWD5bb0olUnhoS9+pD84MkdiR2NSxcEcCBb5UB5SLpD9Pl/TTCe0O49cgUGoHKHcXHGD81RgilZZj+d/QrqxR3urs41HdL8OLh6JDOT99P8kN0fxClZ7NqEYnBgh5CMljUXwMiQwmZNrRtJfmyheFkXXekO+RdKZY+Dpp5GpmndOYwRIqNQW9e5zUczPtj6pM+afuQkCHOPPkDFYQjNZ1WaSg1DXGfyLl/0mvkoO5E4BdBRvSju+suEjM82R1xcFDmd1z3TwXHantZspiJwcQFGaIsmQq8/DYy9wSy+0QqPwJDdqs7LkA5okxLr05/NWKx+WhfpTGaUP6wnPKl0w0Bm8J54nIE1de/A3ZaAvw46rW1KO8NIKfbvupQ6SFczf7/HQ9Vb+afoPmfe5GORPEp86+fXGDhChN2R1LPl8t9DRsAjf0GuyTP4vPlMs/APKvwQXq3vvutLTaYRyqvWYVLMfnbIm8t/yr22XPlEBldCVsV+/dqH1S7sev3HdcqRqiY9aECfIjPYuSkME4OakeYfDzO7jGNQjXklDVkYl89asbumwP4iXSKjJ1BbeNX2Fv328DuTDebax9Av4Fzwix3nwzMHmZnUBLVkfd4FyUBiK9OP2bVW6WDnSByyw4KRelSGBrCutTrm79Dnz98d2oXPjeeVJxdHjuFYLeEHd0GQ9CSJ8Y4RRsFkwLM3kdyZx4C2FSvEYrFjwbGVcw84p3bPF+vhsmT2nkHs74EMscCnct5UM+hUW0rTZqZRGnADptsMiT7poRnShv7Wajr0ZE2YJKmZz1fUwsahq5LhuFxZujNzQUPIvigwOcqDFBi+Y3nd5fvY4D7A9yRPYEUt6f6xKKyujxd4pIGwjztdDqHOQhII73YZ6DnOWJfVVc/Zj7ydBTSO05IWvqDNVfThedhXVGPGxjjUoTssPRyuKxF2nPzOJ7vVhITtsEsqq23tcgDNhPXyQc/Ad4a1+rec4iSFtqP/Vn6FQV1F5kDGrcj7H1FFm/r7An5BcFuRx/hz/mEiKtPtnY5PmaJyjBmTAbFNUNtbzIsNmwU0QPo2zQ4hJFBRitxQOD90a24DEN6yJLo32/Sh10XR52qulmZWVZvc8+a+umCAd46fxbG+xD/Rs//O0MHCDAN/koIJYZlyS9xyY+6VXDHiqIu0ukOZ10G8kUfTYQitj3Tkknk9MfDO3BMOeYkXtYfG7ZWAVQs6Ph+ekjjtDPS96c/gfskleaJKxx/VpnDXdKSO/j7AK3gyyZp7c8oN20OhvkSEZuHmPWdvViFw3XrgEaIgPoJLHA7PGKbaruIyvGW4V3yZe9VsbfEiNoxjDsAU6fB9hb09Tt2p7nl3LxZoRcjJGzOxkPykcpeaj4fINy5ZuQZHx8/T6EA9ugHh/ZvURsGgW/0m/4KbSsJg2ECzQq+bAm9fjjZ35hQRDWYcdndzLH5ErVyhbdyMrU5YbJPw42dw16zVZC9S2zhXHxsGfgDrbRBFI6AG6MKfTERcA9OVi464rCVM98OwC44nR2Y478bg/A1HyLSBRZ0sEXmzXi1tVhUUIxgOPUaFALSRXo2g+Fv4HRlap1bM5kpnppMRRkRd8yB8P1LjOIPBy7yt54jDMc1Jw2j8nifdI0DdUrGG55/LEfDXopYHMpVQB0zxfavcsDgYXmgzGMC8imCFpYIAW0rLjWrt4yoJLredKGbczhaQcZ6oL7T7h33IDGq2Ix5KSTDLA4bmBoEHUZkECkNTggv7tVPa6IiLDED/vT9hr8XplrMIkW1LaCWZvkmGt9RDz0BlLG7XV4sVWA6YJPK+LUCz3PvJP9ztOCWh7s5AaCRMf8q4Iy6on2y5BuDb8Ar+qunPdqv3ITPFxEvitLrfixxCj+DEceUmYpFK1lNtOpBjWdI9uDmHsaZSXggBgvDhBR1ojZyQ3LKz/gh5/8rFqK8rH/gXbiWdkWfQEmOb8D39oVGYoImCcSCQPb67LujJI7S3Kiw3kOz2Co2MSVZQwhfQLx6VHMQvEy8LotRJmZx7mfgTVxEFHFg0pAAdLlXdJSRfIDqHP7i2PAaqlwgLmTWpNRSMEnJsRVytNsGelntPN5Cqmxjjk+lLPMS+qFfr5Y+ikp9c16IrtmDG1gm37qWMSfxS0nFzeInJdlHj5K+B4c861PFmJo3M87gAtPEdxAukpIYvYU0zFQ3W8t/hkGjII/somP4hMilOmA2+vDncVuL7CsUs7K9Xm9BG1yigz36C3ndxOYxeiLqZDNfjsgmWH6/FkMZrZmTrqnppgqBcfuzUjbsSsWp9ZiuL2RN+y+XkrwPKRxY5csEbtA+1ZaDe2kunah/Cwsl/17NhR2t9xN11BeRtvo7y2dSXXqkhpmL4Bm2SSE7xJp2Pp/QhqDhRbPcDd+xmyXAPZPWw2ccya7Z6KIeLtKM3mZE7eGV7m53vFKjBVuOxmPRbcLpk/huG95HpXV41TwYfmHMraajYhwc+knI1qVmZUgv/jrWSehzUp0BvwyrVlRH07ZbnyZv7CWpuqMZ5oly3twi9sZlzMA22AKxeOxTd6Tz6o52HUfQWhivIRACz5q9KBN9KBQZjknpFc3W71JwzJkJfZohBRtPYpXrkYAnoVOVWhvpPhhOC9sepu4sQ4hs0Kbtw2EUS7dvVkz+iwPQNGglk/uDiZC5qKzzHVnI+MLM55aZ5lC/AWYhtH/MuXMgMfIISv9Hh1dLCRSQ24zY3kWKOW5n5QD3wNuXa2n8viAtgK8mD3+uJP90idQHNKkKFV5MGr9RsmqIt6lo2jwyO6E/nOGMcgSobO1bY1Z5LYZBoUVshJP2X9ck2uFZx/4thY6LHzSInIyT1lBRtGRSUknEk3dISwDle3nVw8sue8oFNHofBu2XKsUyH2rCsw+6RRq8tY8zEUvqSr4b2JxLpbD+FcgGIAz/ETAOgwVe+fdpwdbRM8MbAOGJDHiwaDMt4Av7gjE0BXxLm3eGiIsU3nB3Nhx3QItSfWxNG3OsuOgFgjBqrBOK/OECmzFsqfCvDdZiuDxD6ZI2wxo05o8mqvQecide6Aa3mJ++ZyfwNjfXp0uikgPcXwQjGmV8L/K4AXAYrp4LIaZRrza1NhSPNh2WOs3xVyqLoiA4BvGUTGsti59pU1HGGAm76k6FJS23+J7AQOV1qECxOrIuAPE5CFF8HY47oPX/KCwr8ZNWlsq8v18g4ckXnu0oVW597YXupnr1gycY7EPVRKTZmAe04oTIj/co6McJvcKLPXtdOoY3MYUdPAoKzksj/TJtF9vg0tv+pFGR5HiJPyhw8gsyiC6VRUC/uyUop0ybTj37KkK3f8eYKLWqlV5+TbDWr6m0KXLyqxC2dzd6rOTNX6XmtHs52lX/YJi2N4bIMHAZNAHAi/OtHL/+2tAU3ncE5JzzT/QgG/z474fbQlIlMVruEx+CI3Nig4uxpS5PkA1fMfI6bkVPY+P135DZf2tDyQyyp+G6rq2qRvjOO17bSI38h2xNxV6gHKPBHwId0AEZjn+7qWE+hE/h2rSL3bRE95l4HnT8nhO13J6l9SN3ZhJxfsyzmJvR2TultQ28Q8JdafyE1FZz5tCWc30UKoD0wpWOG+vLvHDWKwjxpvV5Kp4njfLyr6X2C6MlKtF0ysrY4AJs5wxvR0bKD7tAFYwzvJrx2dSKr0oNRe7QHkr2aK3Dd8v3SyTqRlLfXJ8QByKbuzLhara6KvqK+BQpz5dq/iBX9iyGzCKF7zzYaswkhdYN9c24BdwDp+uXg5YKMJVXkUYlDKT15kf09GUvpOKepGPvGeja7dTZdS3lhxK7FZP4FKeTsNpgl+L/Qoj7xxI3vQpLeeDcIUOw1G5KltUN8732kakqVoUeUratXOx9FY2GhuAbZJ3FNdwXQJP8oDgRu4rxD8TDRIXKZad70bMGizCZ3zLHQcQYK4ctkr0D31wBsJ+qL/Fj0lFup64w9WOAv7IhKylT1z7IlKFdUaewkVQl3z8kfdXDS4btNRRutDAfRBKkNks/RVfhrMPXwYMJw0r3wMjIQJGaujvBjwLN5wvvIyoIJIj/N37Z/d/7QZLPUPY8vjO6jnBtHRrWyDQbNVu1rQiV5Rljg8eVsVja0EvAb8wHTYbRSz864Q9TVKrHiI28LeKy0RrnGYtqHtSO7UJP7YmNZSY5f/ISyhZbvefuIx6tgpylUY9UYo20rPSiNz272rhbZmEw8dCdEAArg5Fqo8RAH+fFrCkOeklzxL8nqfT8yLscAsT29WsQKNLvgEKI9zI3w52fr6Qpi5dsYzfxxz4FeXcU2yLi2OmWtYpUSlBi1FoCjbLcNSGfmaNHf84OYdvTvvmZyG+L4xpmp0G8g8Vqvi2Wqh52V79BxbG4NG0FNBQcvvFfz1/ZR1y9ieftX6HE7diqjpuC7FnUkMssFw077N0hyHoHIf7HFyx4ucRGtrm0Uv0fBLB587aAwXSN1QipTNJwNJfz0qNeK+a40gJNtnNmZ58l5DdJ7ip7R+ePoDDW7iWGnJ85j8YiQNE4zRlzqCRImqQuqsm3a500YKfgOM+cITjJYVhLX53QCjHzuCe6V96dhAW2MSTfIDOaw311FNeOm7VEHyZQoN8kcXt8BYThsMQF7eGa/bisTDa8Vnz81CZ1qZqe2RIMUBNTjrRD9uZLowMXAw7G6cVz9tu8C5nNNwGoDxJqs77b3B9FVeTdjWG8e0M+2ZUAerxMbqkh58zB4fen+EE24I4lFfNyPV+J9/Gtso9Q3SAc730au1Q/9EmTzAVcJi5dQg9T3A4lJ4wWOUodzwAUPOX2tXkp/hHNp1htGu6N1DA76Pq9+4G7sjkAbF0+GwKUrOV8EDzZtca+dVnL6ivbzDIdylQNvi1T8k1J1moAxUkDFBEmSxTJjuC6WKBzV6tR/FtA5G5y4zFGvTK8OEjpVQIzmzHwWdrwJ+D1vf0zflGaIxyZ9+kpat3y3SqGFFQNA1eWThcJCdHYMXJMh8NrUyydeg/hA/mjbG/KJPltG8aIVvGXWDYqTXP0pNpxgpHvddPuvjnmYuvF/gTkMcIiBA9InTiXritV0YieLtDgFkSK/plrZEqUZcIyopWePkLcc9pwpKi7PCyW07zrdqbmWZ3+MkdRk4HcTob26THXm7qoxpHh0xu5yCxeWCHYL53hQmoOFMvlAjhWiNmhqV3ZeSP9NvxEeGMv/MK4sqgsUAnWL46atf2U1bYaeglP47elGClMr/MCi0lbVSj6ORV0nsYaE5R7BSwY6mExb/xZlESPPseGoY7ZrFdyojAIYM03Y1IAQVSZijsLayDLzbv1s1CnpQqxwEFu8nttekaNNSUJlLSEmjRhwd7VwDF6HiYeuVipi2/dF53mFAElsGi7WgA2YIpRZzLCH9RDmDv+lQC7YgNJoGrvupWJq8GHFJgG5pBWyA2OkI70zosZZ3Zu5GGpGnv8Kyr/VTlerQUlyWWMC8qNmP6705cY0U31FX1EYEEGYCoKnh2Z4Hu4WVAV0SQ27rJP/GgQQPy/UeIGK9zowLagooqVMgr9NWpUv78Gav6DTry3EEMCAP6opI1w60F9+VXOicwdHAbItYF52QCpfYgSEWk6NpKTzRI8NIU91CsSkxJ26MhgbfebPzk3zbOEy8cbIv0I2q4xgJFYf3PF9UPihdem/eOZL7VEuQYWNCiBQPC2/gB+t+T10oFjfmDmcgGzwsncRtHMmLKTa7ObsgsXm1cfAxWKuRAIt62Jp4h8bmwI7pi/Dh7Pzr30rhKASvjrKczGGDfL/mH5keqnyR+QFvcBRYtEsQBxzquCQbfNt6jr0h9OeAwpYlqKGjiUvBFEZuxXEGSRRx2QBZPou4C8nzvGLXVtGgzv+U3j+FBqcX6HdbBrcxdKylSEYTOHUBUU08rjMYizN6ZqCVxDcKAWFjiIshlRQkrl4CZZGqy+nAZqJ7vV2Cv3MWPcQfehix6fwjb9wBGPC6kzHqVUOBTfk1d0mb+lMLbglbDehkNvuBtH2KmQTnar5KGooytC4QJO48grip2J4RCfXxPH82ZkVm36tt0EgK/xImt6/29F+brWJ9La88DNr52SjT4ZBHZtb/2Up0bGJuSFuiwnKBl1v5O2IpbLeAVZFJWFW/D1rFhPcnhnri+ivvlkwibwX2cvZVQGEMsJ9itywj0AF92gAdj0Oj3xErrXuh/yr79iTy7itvBcXFsu52FM2vKJ787NVRFP+5lW4QlXO5kSECfw6qJM5/70GuFE6yVNiVMU0SjGtHe9LpSrpR/Ep3aWPSQ0DaSV3fp/iIKe1EHjrQJw1RKpFoa88O5o5dzmANHPO/XG/tHoxWU9fbyOoweIMFnjZPXsVmhDy54WlOtxYVIMnv4wmDURMx48hop3o/UwipxR14kounH0Hh02eaAdLNssPFPFmiNjGmZei7zE2Lxi7mqfQA34kULjrEs3BKCIM6MS2w0mej/ImCzesfprIfMOZRJXzU40h3F0462zbepbNqsfc184qaRHoEbodExp+pFhcSXRXIksBjqNmv1HbJYaygAioe8o8wJ/FmPRZXraYIYPz3Qyv4vKs3F3HDJIyck1DVhK4TLKw/RvCGF7i1ToUGvpCUtnBKdOUNfiGkhC13Pbx2bdZlO44g/FXBg2p1mTEduNA0xVV6Oc/2JN8sOhpiRUmrFL4cMLOlaBe/PzoqYrmCisyH3Q0h7t8o8aBjZ9ZxKPOHrJW58RlpduA8QS8lIYH4JsLP9PhSFUrUC+74dAUnWbIoiCu6qGWQFd5aRYoidoY2zjENHS0tE7YRTigJJuWAvLgDmQmcbwJwOpFQSM5Fpf+aIeWGDRIT447AfTKPaNKnCKPypIclex2KZQtx7EHSUWq+O8qjkO3da7HCL/KHSWUV6j8UcnslQ4Pm/ZSSMu6d1hNqBVx+kPXdrAayf8SxdC4CKtgb47/0LfMz1gNACqgxcViXx44ueIbVS4xs3g/NzAaMhH/x7GSvtgPuZpXcp0Yql3+Ky83cPr1lASrta5IiMMF9v5ef0p0CY7xxElN8PKW96W8WSS/AF27ECe0HgOw+9aRE3qGn876VLX8S/hvWuxXqSO731D3nlOcuytHIaeWk46QBOJC6G8yXo7eggpELfMYnUpWxe5T7KIcdzApJyTiuG76rlSpgtyEEz6Nh1o+RlLCjiRM2aks4m4FTSX1ZZVzmLRYL1cOKhr1GoMo2aBwgBqhBHrRDugiYv7txvK5Wop+9jttdFN1wpg5dY+WMZ6HRxnErboPpCUCAy9AxggVF+gPHeuqhJiQ7ZVGyLtQEmgBTNKrrQysNibd5Zcph1QAeffjqSX8zutYYaxm916Y0UvlQc6Lhla+MygYSp5VZ9uEQjhLgwJLFAnwwA6zrwmqirshAd4uSU+ny0iGxOP1nlP2rVNswwEumfoV/kh1Dt2nRqlaN2yCZozjWoCyBKtNve44fkaxepBNCq2rTAEUFZfoR9fuG/+NsZZR2x533aBgReBJDz8/OlgqXroeQVBn9kRfCLHiGEdfntpzd0JGTsz9O4yxvUL5zDjLNyTcOJsAydGb7bl7v2eJeiVFGrlEoV797bkWzSl6rM139gT2m9agOkMw7j1mVSCPcJaaqQQ9EGCk1K/VrDVgudds08MWrybptp3o+E3mYlcgl5ab+VBawahzoHfN7SviV/fUKWOT7upqq/U0NIxg+cqKi81ECbqoh2b/4SOs/9H0mZhBSL2DB5m2fYTEpRQeY67znNbJWelvBXQckU/uvuFfG0hl3jb+PhsGpSaB412w6yfm5+KUaB/vOSLu5vUzlGRtXgLg3481V2V2Z/LjooqUKaTFlNPmw/AE0BIFiUmlgGEKAk/YdgqCrWWbHamXXcr/OpvQGT3X0kwQUsJVQ1GBPWkwk2m3NURyzYPsv0gh9nvSb0A1/BYbxdAIOsa2xAhRCA1M+h1Y4cgXC87wJnjfkzKc1nYBNhpHgdWP299kP9cB80qn+FL1DIXhIuTyKWQPki3E3IeIxD9Z9Vd8GaPAfdhUYmxBdIa/0M9x+ZaMOtNX3qJMJ2Ax3yYOoieusJArbZCivv1qztiS3H4jTgljwVEzLaOAk+rksPfh7Rb54WZKoKc5t/T5CF2tNa9Y2wabEsr+HO8QHZ8CNXcolqaa3OgDK7EPYcj7FImgzaeGaIfbQn5+bB1rNSwZTKMUiGS1eIIJiSrn8aqCN26oeHBSCOG6Mio4fQ8YHi5zKDItj/LoS3d6lUIvfaZfAq65Dt2JKK6ZA0ZB1zTMGWWIr5mhdMrjOXQEIF6OgjpoF0Hfr6O0RUO3HO1hRIfrlcPLoPy9Ku5saiEHwWXIpaPu/Mr+Q36AidAr39VL5cA8VHLWieJc9mzszFO3E5UARm1eZsNmrSK2ZQuLSDYqQvolz7RA3TLstFp3fV/gEjm24oXSWbGvK20JmXZLcHQ1v5rjEe+V77sabUSrKN1mpEn/1wNOR229rQx5QmPteh/jb0VBsn7pCKxo3PxEuNQxo4bC6xNpBV04yTMTzKl7dqa7x0V3SWRSjMTjGJXgW/5ibfYzgx0nWx3MjoS3gBroSRNCoqod9wQWmMNDGWpsjUdDgjvCrgDYq0bvfZJ61cvm+jChib6O5iumNQ3c9rfKYteCD2qTdiL4pMnzVw5Akux2EjfNCWz9l23jSEGAkE2vhQ+q2+lGDX2JiA7YiAhKXGGMaPj2hzZt0bLEfwooWO6AZwLZTKkypQ2Tjkwa9xQTODbFJZ5/qR7l8cM9RV8spDYHiaCyDhHuVZoBJnFhdVKiJtWtnHJbExXoyCjue7oQGh9+c3r1RZoJaYThYNA7XgrZDSaHaXUKKlK/0xu7L3GD7k/oOIrOk77WNtHF/6NPYydCTG4rHjF3dUEzlF75NyEh1crMX1TM2sqtjcZZo2B3B+F+LTDQFRJenSmx/0vah4q0xBXIucsq7wX+sQreo1YC4qc3SzWrqdNLmTwbLBC0f5tkSGqJcoj+JgfqTABE1hFNSLBWX8aPklvXVt/GsRBwTv3x7P8WDhyAwPcx8V934NtuH4G2F3VFTEKgGmLlo1RmrZ7qdo07vrNJnUhmhKevd5qphbo8nxwQLu393ut+0XIl7itOc4TUb+ZpB2Kaw6XTJ7y+YJO1gVhIwe4LZDFAYW9Ftw4aHoZd7WWGekf+lVdVCdkgsvAzhlAl+QIi6bZehXNJfJz6I5BlaKoa8we5OwBFqqVdUzZb/z+b/x4Yn92F8BKSzIRQc/tH8oeDxUTJuc1ufppvFXHIjbQzIh9/siM10RCy0RI8H2tm/2KQ5Cck29eJ077CgFOCM6Nwl06erM5Ps4446a+WXpiCUSGsQ9yb5Y5kT7BrVBzJsHsJAXwmzJ2waj1FxKXsBhWPOGS4bxOrPPjg3Xtv44cgt2JrEHXI2s/0Xsrf1S7qUwx501agp7VqhTRKc+JtCPr2eh+SscySvLcxsogjpbxZATp8M7FUnu1uW7ZIWPRWBdDTxlQwAwKMJUhrqAJfLs3ogE9BG4kKh1s8xLWGWgU0fIFZxxzM5jP86qi8GlXLKLS5Y5+7t3JoTs/e6LT7MeZO/z6A1C7tZ8oz3Dcdi09NQrD76mYNhKOat/RDM5wcAmmzq+ZEh5ERxXaAj/SZ4L2hD9qufZ6AuEQhA1FOEP9EFkuvAEvYzZOhI0hWFcHXmxIlSflUHOrSOWERl9QpG2a5ldCIFI7ISPpKgJ0Dov+2WMtLIqAlJqXntR9cf59Fe5NCcvo1NsTxYqe+cm8FabpU/3dPSx7KKzH4wCjh/RgZXHf8jzv7rBtUmmF/zqVG1uHpMWC9o/bnTWVzY7fqv7VhJws3pfwAwRitN4Gu8swkzhsjPt62oDZ1ZKOMgrVS2nZsyfkCNEc3wS140rvMYQjXc6GRRUsjTbrTwqRCTZDMeHq8ez9Se+bA9HpD8QAPm2ecdQ/oBPYGo8d+Yjaz6rJlnq+WlE2BZtr3ozxLegYRj9qKYad2d05mgdjon+CU8fW5V+xGlizJR/tOGCVGJuEV21FSpLH++jo24VlMhXogNuh3y4gglb8aPoHZqlZY5d7SLKwrmGdoOzebwqcxPqW9PloiLnsIZvr0mthp3LNzT0sbhkXs4LHY2tFjcrrwCf/GsCTn8RCue1JJAFGqCQBoD2NRH6EmP9IA34T37WSTW1uuueh31x4ODi3/JdI3WWksZB1BDMYXLw3uaVLyYMvOxAsAL1y6q2ZVwAyVgdr7lGoYCewH66H7EuCijv9tpUp5S50WIB/sy0ax4j15BUgfAWtgjxKahoavx04c8olIxSJlTs0jW98sJoOz4P4LBIOwuYRXmK7az9Gb8dfBqqhIw+S6xA1kdnY/yk/FLqgJkQSNejlMzqRX7M5A6mh0ZW+nMiSGrpNgq4qNTQEO6JAxIJLK2zdfwwNtD4ZowbKEguC3YPCNVBbB0HABlsaAtU3gib61eh8msl0USjioFd0RBVopXa2mtKnBWITIubm67NHEBdN1kt7Bz7ijAP0drbDkmWCzylLdIOkWjMkE5E0AaBmL2z1QNqZWGF7QK+naBCR33uWceqqBZdq6BlMgHlSfhs7nUpA74eWz4/S0N2Mw8JOck+ihK15R2FN0BMfLcn/eXB5FA3gKJX6BPj11RvcocsRCBPGHi8bOp+tfPZrINQ7FwQxTmCVkwMq1aNB2LA54CODxuiyyVC73JMxSHIPk61UINFxfgd6iv0qIqfjOSNiYy9QRHMSEJRZ4ut0mnpLCHhSST4aTYIGXw56NKdNNebC/p1YzJ2pkJr8ZwdDbLzCeimHvnoohKHAyBRJSRmtOl7C6Pxxt+vFkxmvNPwZsUiEdNlWIuCZ1VPYYW4B67dttw7Hvmkt3sLJSlu+TFcxr8oW+5TfCSdRcfFNaSZzQcZ/Jv+I84QdijgQ4RDipdG/l82mncQp42pdDon1DBUaExl+V7436wtZ8vWwADNla+iV3rQ67JPHIArRkO6Lx048QmAzuJAQkkXxlUd7qhpvCMZnO8ARotaaKk8XToIQd+AJmoU6OWSEWhPJK5JXovNfjI7sA6mIs0YV6zXALRBOGMxOe5aLCPdMNn3fcO6G5Qs5gY4UhoLQSKEtoiTfz9d6aGhCBD+xH7A1qP7rGv6n5/BBD26Ft2mQjyGEIiKYtnSVmAawyEzuU+oGhITqxk/eBbqnnt/Sdd2vfT6bYUbky+iAtWyekCYYh3ZPFEojmjAes5zg99BQqUTsUvMcsbJfLxWWt63dAYvthQpu/ZmceUqbdPYwg79pfL9mloCflXefC8/sb78pAVthlAmke0n/QlPPV2M0nUB/1UD2ZhQdmxOwzPBMddYG2XSWuIYgbWk1qYS48w9vu4z4biw5qqmsRVmbPJg3f9Z5Jtm1Ebs5B2hJwCOJ4hAALnmxEng2EFEwogJ30sjJBcY4GQGGl3/w8PBF6ZlhIYJrnukiPynNh6pAeF0SW1/HQCpRTblD1GHD3tFWzT0zy8hAk7vKOfxPSANVNmpSl1hx+WsgJQth/yNcLsNRyqpebFD2rI73kVuWAy/SNN5XB8SpdafC7aDfjTlrt48Gg/LM+IL9CICg7gSmYKCWwx5Vwv2KirGOKjxmNDgppOoRvADrAt6KXDVAGHqnxwcSha5FnMySTkFWjl+FfkUivZ19VFz3UywCiS4tmOlPFkZyiR4H/vHbcv62WSZ3YW4WzonbfKahG5QJTsfGmoI1szGe22BPtE10jEIL3bMLmJhODSc1zZcvgtGF7iOjaAuD5hmSFr6TzEbVMWMlIbLP9uBgVScJ2SKdt34kKyofPRqqev39xvAfQZchwUzWquQpLcPcCQEETzI9ZhoYY40AzLV4DnNGq6ID9OuK8berHe4mBJ9aBzjPikssu5lK5w2u9WW3QY6aGFtKyyWAPLDkYovyTTziiQBnWh8nFYYQpW/PSPxJ4jzP5SNKrX5AKD04JkujKxD1qoyX3JuhHCjNXGxYGk8Kf83eysjuwKyWPV8M9nKT1a9rKZVBGEBhy1viXS/fAsV90jOZoNegQJwaKWjqHQhTpVa9mgGiyuPa/dzJoJg1HlFdHwL06Y4J0aVpacSmHRsrNYBsxxc7GuNLDwS3C64J2y8ymXYXlqGI7h8cbClsDgq0Y0l8rl4CHMir/151cL/M/sB+Ws+IYe4BhRkwi8S1WX98c/ke1jAhS47ahiR6PkmIaXkFtmGcUVTkEDsPhDd5nxFZAW+Hj/nqCuk821KzKZEVQ5Y51bxCTWnCSBHvoKY5reZQxSAbY8JB4chWxhOZRSxayM9eijCaZisk35dSyGpyuhwgKg0tfbs4gI5NlP1RhEn1gi8XSLDWwRDKsuW4l2NGHLmjThB2oJ+2A963eBkZG7LzY1yjtU+AkCLbD73sxKNDWOltqvbOnOd6XbigRLcoYgTyFnKqggTmYGEcjRs37SDF/yUtEB/Umkm9VOGZQbVwuu2vBI/tFf9iQk0aIoM0ivJAzlSW7mi1XAKYMrdMWkDCJEUd763+Xsg617DQP3NF6B1758s6G+K2Y9AM1MYlSRAkuUPOn+w++cxtNrWl6esOJzOmVobIasdIUla5LobgeAx5WYxaNkxV5/6yr4XoQdTwTUsMq5NHIEt5ldB6+l+x79OnbLkSONRJ0ODWCH6igenPSh3XOISWkY7c9lgo0Zn3DgHVqRhDUw+CO1uxmE2ed/m60MVjFh80/1hYMBuazx8xwXI94YMpZminFu3iejMOPLdLsmFDPrWr/vQ1GcmjtY5AZ/NG5PU8KdfKZkzOAkrd0sLxbYatOMCPli0Robdr4uCkxc8EYQZ4Q9Kr+NrYq0SrxkCMzlbuNNKWYpUhHgVn+1z304L7GCOhmZVXRWYf8DuTsJAw94Ba5N5ORebsdbU2dw9v8OmWM7kQ8hHHWOwp4SsiD6lWavA9pofKyVLm55dlPSaexZi1/l15gRbqYaHQUxn9Cve6VHPBjP8KVbufLR+FmStid3YK/X7Eruxe97uMrP6VUzHNAldZCcc7ayrCOOJggCyw0cNGdX+FEZngXUlXjm3I4JsPIweVX78Tdqxkwyap9ERei4rz24PPqM5lmuh5iQa3BCd4CBFcN60M30m58T/qDGTRMtrQyWkwKh0MP03M07gn4GhD8pfVR7K4GakLHuL7HIe3VU0qiI+LLJGtijwDJZASFm8ROcZrRuOnzyifIexWM1YfxJ0pwJK2Ue7IFN6rtzVimGcrkg2nl8D2O+Xszkw0r6lXyiuT70Tf4bSf0fjcA/N2hYuoHNvKlaNXgxTgwUeR2Lsvicj1cdBKgGVR+rGAVwTzsnhSEZ0AfzJK0nhuB2LhQcFmfw6HLROFWXgddpiKHKCTTVa5F50s+D/XSP7O/NTBK7aEEi1s2uLIrCDO9G8ER7rl3ttvuTa8v5m4PHqRxzNaVR/l6dbVnphojWzsR/ZyS+gSdZq+En6h76AfPYUs9p3eqVMw/vgghO7vjCAWgnGQQekDHuQOFNCLxnD9IRcOMWnulMPh8x1tVn0C9UzETLJdGzhjXFb6ToKhKiswpk4GOig/SqiKrC/2vCed5BmdUPt4sSUwqjkuF9VwBqV4OY2+Zm3iEI8DLMiNjZLWouELKCLBPZnLKclMVoaK/y5un7ezqb36Eko2xwn0A2MENC81tqbi4pau4buOgS8wVszuOsiEqfrI+saEqhbV2flkj8DSmnmsM6G8kRbn0rkrTcQOQZGEEieaGizLh6rHgAHEvIbcvsir5XTKSBgGsim6F5cjdeFJz+barDT3LeaOWxksEHF0jL026q8YIGo0hIgC4L2oyQcS+X/a/PvvnMwv6JJqXbCf3J2g4PqPnGnYZIqSOWUdr+47ojKXuRcGb6SeadFOVwtubrI5k14xi2BiiYJMXVga9psSpsKMtOeDrQBgAeGUJ9q2vt5pzQXEbAQKAY4dbT93jYDU+ox1MaO/inAg5PPVS01kBIIyy6xzR8/9fOsQBmJy4ktA3iEwsWFzhxxrtK+dfUxdbzmYDO/nOO/zbneDBAWUXcFP6yHEhZ+JcbAiMTux3lwoskoEG5HXj8u4F3PHevNJR8Co6ARsIg3/SatRyerxxfdGfQSFidrZoXuoR7P0Ns//I7ouI2sDIxWjH9jJR8saOqTCCjtDx7TwUn20Lur5oXkcZ8GafOESfWuRUxVfinQTTrN+4Ey6VyK8vmM0u22R2qEVbznC8i/JRg+iiAjOPUJqXkIZa91U6h3yZhB1QYjSxkuLnrmt0w9uee48IpegBx3ggOEhtM+5Rl1HouCZwbxxz1xC1jfIDIcrnuEHtVIgnbI7kBk9WS7MfaZrslMpy/98NCvTCDYTWbCrQak9uqHJWsoe1WIjWhowtu+BOoi/L64Tx0iHLKZ/DCxdmE4EpiTbm0aYHOjfdxtDb5+9mUtJN21EXpdQ53yVlOawL9I8UOgx7dovwGsTyQgB9tS0RYQz2nT6cteghfJfeZJ8s/PvRWhrahLqqKVXn8s7GcqZeupR5vr9zbLSTBTLr16QH+JikEmd/Xe/PjX7m+teCFRAs8H0D319e7fZFd7nwXPnmW+f17vdj7Q2XEgdgXlrUvKZ4VdVY3pjsJPSMsjsLj8GN7+UiHMAEfmzUsyr9+dnvD+9kOXMNik7p02sOqHBJWvKPvHSFF7gcEb9MPAgzjclOV++cQ5+MXnVzrPIRL/1hqqZEBAM5nMVsY/bAbpILRnOYi/g+hcig6Mjh7J0RTJnqIXTU2LDUlYiIirU9qlx1l2rah9G5HFVFRZFpv343HazfnD4kRMzdytP7D8bNeshfRcPmYYEi2pJlkVVHNwA+uB7VSPeAguk9qEa+D1slPxM5Y+b5DbbHDSJtR3zDFmWFHo89iWYOE9aWZ3JVCijsCS7qa7pF+0Ie6ik4OuvVJ2rSCj/QQc4qHHywPolHykbda9mUGUELODbGsieit5IaMGCM7cF3iB2sHKuzJLvcom72ExCceBSGA4SXW49y7Qw+T11XAyfVZw+PsNLnJq2hpjL/gN5MpXkQEgHTBjg87U6l+46ffO3MkaYkLquGOgU5HTrebPq5OH9YS3kk4Yas2320RO3mwadBNZtjvaqcUVkPI9/EAlRsPkEYwM3RMGWttmCXu4EzAEL6jiCiRi3D3nJ2sHRT38Yyc+jQ9dDIBPOobPNmSPb5cLF6MGhSN4kYiWvS4pa6nPFj67rFSpgjah7JCusTuMnzMcwS2BlwshOyXH6zor+VEdTiqWHhcFUFLnqrWdJsd9cZARkLe48nlmDsrLUULelcswmyorc6AwMdZqWVwcX22z+Pz7icsmTqpPt7RzfjfO+PiGG8pF+ZoGtTX/K0EUBy7/Esbxaqs+Cnqmk9L/mfSkxtAzGG/n+Y8cCEvGDA3JjpJRBradTJoK4MSxLRrG9pGkCQ4fyZq485SZ32cVxdTgMIpmWypTGZ3N85rrPRRX1OQ6YfwL4+wNeVVGHWe/PQWFanEmRamWfgC3riQMXN8+VGMY/GoOvy1u2fBxxID0HTN4NvEK/JRGApcZWITIikGjtgkGXKe1KTGzEYPAeOSQvXwajuqfS04E7gfbPgBWC2YLqVbJ3cMsnyLKSwzdRf9w9RAY7u23kMtMUoAfPHpuRMCcVK14lw8JZeQhlNTbDLSASHGgaFicGKVCz5b9GeiGI/09PU8TMI1JQTuEUpxmk+vpgs5MbQwaA91g2orIQOAhWL8FeYX90+Cc2a9oK945+6kogkEvORnlq7Chzy84FrqEcpeMGerbuq1CveDBSEyl/18SjQ6gFd2QR2chAMx2K8mGRgdlrcR33z6WAh9rpcBvB7Tb1JOKsoYyAdhi34zIZwgKLVDGfCUdZTaowOx3otvCl4fG6NC0prrvW9E9dVKewA2FpCeEAxv6KTFMz+sCHFwa+NTZ5rfbiF4Rza95VRLJfhR+9ueSTzieEkhpN19D0IujFgIcO4cAF6b188YkcZIG9ao242P4h4yAFvyzj+OMwVAbRi3j9fBkPi1hwWueVbbbqM6A7qQRTawAsDWL7OXeXLMVdlvbazUC/KAxRUC9H6/o28i7M9DDRXGGaB0ih+JKrgq7eaJEoffbKrESYkkvHC0WuHmoymGVQONYOOmEN+XxmNV2yUUKhDOWSwzZSfw1fitYbRCFPg/4xB1qA+ItWY5Gkrycwf7DC2u4GNSlh0d87FWDjJzluRWK+eTQs8D/K1A9AAFJLSraAD+ZdmC4c0xAwddod4uyOsoJ/q5G1hRpbIN/kKscfNxzd8xScAYK6rBT3WvGKTZ9j/N7LEcFBvj8jh3oZ39dXCUbK5YTKQQfcoOwl2l2SGq++PZ+AeQiQmNMdA1NAGZ0XQRqncrvD6+oGmf8132j2vaYNTzV2uuiLGi/Xopz5fg0Qk/Bqbsch7tY/xna+Ktq0z8nwy2fAi95exV0aEhfoypuY1P3WT4lc6IJHfKeqH87pEoaF2HaYdMbfd/JYeLfMBEmsG+qA39mKpyb8gWV960/N9ngm3BAcY4h4q4S8NidbDDRFF+k4cEDZ4JgA9Y7z8Mzot4NViEHm13zyO5sihCmox/hy2gAXNwlOzlIx0UKfNy9ClZQci3Ieo7szSurMBuydW2q5PlexT1IaKWv/RCCBXulYF+QiQ42OYsfNkncJ8C7X1nb7Y9cEgAZh6EK5WEUFh8AgqW43PprRRCqyyK+EnTEAbQJmi3eUUyoplzArU81XgOrzRDXcp8/HYbw826I4jtUMn6OFqEE3rKFdDwBrMi+Tuv1EHDQ9HqWgpAMIancoWXBWcyeyMHOjbADRrcp3Eu/alrKkABHcrW9vECsjuqraWef1wI4ZYHWJfQRiXq9UgbfNxoX+DiZk/BxsDRn/Q2z+xrQwpkv3mrAP/35LRIaWQ6i1I9JSCrU/Pd7Cnm2b/ixjkfSXYznvN0M2czmF+fdubdNlMx0TCnzcX8lqQQh/6YURxf2k968u0t/VA3rx0aWlb/uZlfbi7v9xUtpNP2uQy0ivO7vG0L1xFWlYoLPAVH4mpQTMgujtgWtIpYi4neGJ33wRer4OiFP71U1tmWe7/r0dnSJvj+dSGN4Dk+rLkZUpr2Ke7zGaqsf/2Q==</BDB>
    </BIR>
</BIR>
 + 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 + + + +#DRAFTFACE +FACEDRAFTVALUE=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 \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml index c2f0bf88e96..d4e84de60e3 100644 --- a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml @@ -776,6 +776,41 @@ AddIdentity: "introducerRID": "212124324784879", "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "IDR-IDC-002" + } + ] +}' + IdRepository_AddIdentity_with_morethen_10_digit_numbers: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: idRepository/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: idRepository/error + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + + "UIN": "$UIN$", + + "dateOfBirth": "1992/04/15", + + "postalCode": "14022", + "email": "mosipuser123@mailinator.com", + "phone": "9876543210111222", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", "requesttime": "$TIMESTAMP$" }' diff --git a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml index 597c3531ba5..108b44db2fe 100644 --- a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml +++ b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml @@ -1548,7 +1548,7 @@ BioAuth: input: '{ "bioSubType": "", "bioType": "FACE", - "bioValue": "$FACE$", + "bioValue": "$FACEDRAFTVALUE$", "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", "dateTime": "$DATETIME$", "deviceProviderID": "1873299273", diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index e3f7b44f478..318d5d4af3a 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -162,7 +162,7 @@ DemoAuthNew: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", + "value": "auth_AddIdentity_ValidParam_smoke_Pos@mosip.net", "key": "emailId" }' output: '{ @@ -210,7 +210,7 @@ DemoAuthNew: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", + "value": "auth_AddIdentity_ValidParam_smoke_Pos@mosip.net, "key": "emailId" }' output: '{ @@ -1081,7 +1081,7 @@ DemoAuthNew: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "1970/07/08", + "value": "1992/04/15", "key": "dob" }' output: '{ diff --git a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml index 0da7268b342..919d3393603 100644 --- a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml +++ b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml @@ -64,7 +64,7 @@ EkycBio: input: '{ "bioSubType": "", "bioType": "FACE", - "bioValue": "$FACE$", + "bioValue": "$FACEDRAFTVALUE$", "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", "dateTime": "$DATETIME$", "deviceProviderID": "1873299273", diff --git a/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml b/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml index 15252e1c48b..f16da62e279 100644 --- a/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml +++ b/automationtests/src/main/resources/ida/EkycDemo/EkycDemo.yml @@ -23,7 +23,7 @@ EkycDemo: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "1970/07/08", + "value": "1992/04/15", "key": "dob" }' output: '{ @@ -205,7 +205,7 @@ EkycDemo: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "auth_AddIdentity_ValidParamms_smoke_Pos@mosip.net", + "value": "auth_AddIdentity_ValidParam_smoke_Pos@mosip.net", "key": "emailId" }' output: '{ diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml index 873747edee3..869067e50df 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml @@ -83,7 +83,7 @@ MultiFactorAuth: "individualId": "$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", "bioSubType": "", "bioType": "FACE", - "bioValue": "$FACE$", + "bioValue": "$FACEDRAFTVALUE$", "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", "dateTime": "$DATETIME$", "deviceProviderID": "1873299273", From d09b0f9d6eb4c2c2d0b3e490ec54727abb85f9f7 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Fri, 15 Sep 2023 18:48:26 +0530 Subject: [PATCH 152/204] MOSIP-29418 --- .../CreateRegistrationCenter.yml | 93 +++++++++++++++++++ .../UpdateRegistrationCenter.yml | 41 ++++++++ 2 files changed, 134 insertions(+) diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml b/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml index 165417e27b4..9b9b00a6b1b 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml @@ -169,3 +169,96 @@ CreateRegistrationCenter: } ] }' + + MasterData_CreateRegCenter_Blank_NumberOfKiosks_Neg: + endPoint: /v1/masterdata/registrationcenters + role: admin + templateFields: ["name","addressLine1","addressLine2","addressLine3","timeZone","langCode"] + restMethod: post + inputTemplate: masterdata/RegistrationCenter/registrationCenter + outputTemplate: masterdata/error + input: '{ + "addressLine1":"sdfg", + "addressLine2":"", + "addressLine3":"", + "centerEndTime":"03:30:00", + "centerStartTime":"00:00:00", + "centerTypeCode":"REG", + "contactPerson":"rtestsd", + "contactPhone":"", + "holidayLocationCode":"$LOCATIONCODE$", + "langCode":"hin", + "latitude":"78.5478", + "locationCode":"$LOCATIONCODE$", + "longitude":"45.2456", + "lunchEndTime":"00:00:00", + "lunchStartTime":"00:00:00", + "name":"Test123", + "perKioskProcessTime":"00:30:00", + "timeZone":"(GTM+01:00) CENTRAL EUROPEAN TIME", + "workingHours":3.5, + "zoneCode":"$ZONE_CODE$", + "id":"", + "isActive":"false", + "numberOfKiosks":, + "exceptionHolidayDate":"2021-11-12", + "exceptionHolidayName":"", + "exceptionHolidayReson":"", + "version":"1.0", + "requesttime":"$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-307", + "message": "$IGNORE$" + } + ] +}' + + MasterData_CreateRegCenter_Negavtive_NumberOfKiosks_Neg: + endPoint: /v1/masterdata/registrationcenters + role: admin + templateFields: ["name","addressLine1","addressLine2","addressLine3","timeZone","langCode"] + restMethod: post + inputTemplate: masterdata/RegistrationCenter/registrationCenter + outputTemplate: masterdata/error + input: '{ + "addressLine1":"sdfg", + "addressLine2":"", + "addressLine3":"", + "centerEndTime":"03:30:00", + "centerStartTime":"00:00:00", + "centerTypeCode":"REG", + "contactPerson":"rtestsd", + "contactPhone":"", + "holidayLocationCode":"$LOCATIONCODE$", + "langCode":"hin", + "latitude":"78.5478", + "locationCode":"$LOCATIONCODE$", + "longitude":"45.2456", + "lunchEndTime":"00:00:00", + "lunchStartTime":"00:00:00", + "name":"Test123", + "perKioskProcessTime":"00:30:00", + "timeZone":"(GTM+01:00) CENTRAL EUROPEAN TIME", + "workingHours":3.5, + "zoneCode":"$ZONE_CODE$", + "id":"", + "isActive":"false", + "numberOfKiosks":-1, + "exceptionHolidayDate":"2021-11-12", + "exceptionHolidayName":"", + "exceptionHolidayReson":"", + "version":"1.0", + "requesttime":"$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-MSD-307", + "message": "$IGNORE$" + } + ] +}' + diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml b/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml index b0ecc3ae72c..a4e93d778e4 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml @@ -38,6 +38,47 @@ UpdateRegistrationCenter: output: '{ "name": "HSR Center updated" }' + + MasterData_UpdateRegistrationCenter_numberOfKiosks_smoke: + endPoint: /v1/masterdata/registrationcenters + role: admin + checkErrorsOnlyInResponse: true + templateFields: ["name","addressLine1","addressLine2","addressLine3","timeZone","langCode"] + restMethod: put + inputTemplate: masterdata/RegistrationCenter/registrationCenter + outputTemplate: masterdata/RegistrationCenter/registrationCenterResult + input: '{ + "addressLine1": "HSR", + "addressLine2": "Venkatapura", + "addressLine3": "kormangla", + "centerEndTime": "17:00:00", + "centerStartTime": "09:00:00", + "centerTypeCode": "REG", + "contactPerson": "Venkat TestPerson", + "contactPhone": "9663089998", + "holidayLocationCode": "$LOCATIONCODE$", + "isActive": true, + "langCode": "eng", + "latitude":"78.5478", + "locationCode":"$LOCATIONCODE$", + "longitude":"45.2456", + "lunchEndTime":"00:00:00", + "lunchStartTime":"00:00:00", + "name": "HSR Center updated", + "perKioskProcessTime": "00:15:00", + "timeZone": "Test Time zone", + "workingHours": "8:00:00", + "zoneCode":"$ZONE_CODE$", + "id": "$ID:CreateRegCenter_allValid_smoke_sid_id$", + "numberOfKiosks":12, + "exceptionHolidayDate": "2020-11-16", + "exceptionHolidayName": "TestHoliday", + "exceptionHolidayReson": "CenterCreation", + "requesttime": "$TIMESTAMP$" + }' + output: '{ + "name": "HSR Center updated" +}' MasterData_CreateRegCenter_Invalid_HolidayLocationCode_blank_eng: endPoint: /v1/masterdata/registrationcenters role: admin From 1bd189fcbe3435ddca5581b88bb7d4192b6e7f62 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 18 Sep 2023 09:59:33 +0530 Subject: [PATCH 153/204] resolve conflicts --- .../src/main/resources/config/Kernel.properties | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 9eeb34c513f..9eefc27e090 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -authDemoServiceBaseURL=http://localhost -authDemoServicePort=8082 +#authDemoServiceBaseURL=http://localhost +#authDemoServicePort=8082 #To run in Docker -#authDemoServiceBaseURL=http://authdemo.apitestrig -#authDemoServicePort=80 +authDemoServiceBaseURL=http://authdemo.apitestrig +authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# From 86e6d6b26dc4f0bbd6323810d5350b08e7debdf2 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 20 Sep 2023 12:23:28 +0530 Subject: [PATCH 154/204] MOSIP-29380 --- automationtests/testNgXmlFiles/esignetSuite.xml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/automationtests/testNgXmlFiles/esignetSuite.xml b/automationtests/testNgXmlFiles/esignetSuite.xml index 0946e08f1bf..e950b02e35b 100644 --- a/automationtests/testNgXmlFiles/esignetSuite.xml +++ b/automationtests/testNgXmlFiles/esignetSuite.xml @@ -468,6 +468,13 @@ + + + + + + From ba2513819875a70e01b373f681d27de5c08c3a2c Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 20 Sep 2023 14:19:59 +0530 Subject: [PATCH 155/204] MOSIP-28365 --- .../apirig/admin/fw/util/AdminTestUtil.java | 31 +++++++++++ .../GenerateLinkCodeConsent.yml | 16 ++++++ .../GetLinkStatusConsent.yml | 17 +++++++ .../LinkTransactionConsent.yml | 16 ++++++ .../LinkedAuthenticationConsentWla.yml | 51 +++++++++++++++++++ .../OAuthDetailsRequestLinkedConsent.yml | 24 +++++++++ .../OAuthDetailsRequestNoClaims.hbs | 16 ++++++ .../esignet/SendBindingOtp/SendBindingOtp.yml | 20 +++----- .../resources/esignet/SendOtp/SendOtp.yml | 20 +++----- 9 files changed, 183 insertions(+), 28 deletions(-) create mode 100644 automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNoClaims.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 63c9d8b49ba..14acbba3836 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -204,6 +204,7 @@ public static BioDataUtility getBioDataUtil() { protected static File bindingConsentSameClaimJWK = new File(getResourcePath() + "bindingConsentSameClaimJWK.txt"); protected static File bindingConsentVidSameClaimJWK = new File( getResourcePath() + "bindingConsentVidSameClaimJWK.txt"); + protected static File bindingConsentEmptyClaimJWK = new File(getResourcePath() + "bindingConsentEmptyClaimJWK.txt"); protected static File clientPrivateKey = new File(getResourcePath() + "clientPrivateKey.txt"); public static final String XSRF_HEADERNAME = "X-XSRF-TOKEN"; public static final String OAUTH_HASH_HEADERNAME = "oauth-details-hash"; @@ -219,6 +220,8 @@ public static BioDataUtility getBioDataUtil() { getResourcePath() + "BINDINGCERTCONSENTSAMECLAIMFile.txt"); private static File bindingCertConsentVidSameClaimFile = new File( getResourcePath() + "BINDINGCERTCONSENTVIDSAMECLAIMFile.txt"); + private static File bindingCertConsentEmptyClaimFile = new File( + getResourcePath() + "BINDINGCERTCONSENTEMPTYCLAIMFile.txt"); private static final String UIN_CODE_VERIFIER_POS_1 = generateRandomAlphaNumericString(GlobalConstants.INTEGER_36); @@ -305,6 +308,16 @@ private static void settriggerESignetKeyGen8(boolean value) { private static boolean gettriggerESignetKeyGen8() { return triggerESignetKeyGen8; } + + protected static boolean triggerESignetKeyGen9 = true; + + private static void settriggerESignetKeyGen9(boolean value) { + triggerESignetKeyGen9 = value; + } + + private static boolean gettriggerESignetKeyGen9() { + return triggerESignetKeyGen9; + } public static void setLogLevel() { if (ConfigManager.IsDebugEnabled()) @@ -607,6 +620,8 @@ public static void getFileNameToWrite(Response response, String testCaseName) { fileName = bindingCertConsentSameClaimFile; } else if (testCaseName.contains("_Consent_SameClaim_Vid_")) { fileName = bindingCertConsentVidSameClaimFile; + } else if (testCaseName.contains("_Consent_EmptyClaim_uin_")) { + fileName = bindingCertConsentEmptyClaimFile; } String certificateData = new JSONObject(response.getBody().asString()).getJSONObject(GlobalConstants.RESPONSE) @@ -3060,6 +3075,17 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTSAMECLAIMVIDJWKKEY$", jwkKey); } + + if (jsonString.contains("$BINDINGCONSENTEMPTYCLAIMJWKKEY$")) { + String jwkKey = ""; + if (gettriggerESignetKeyGen9()) { + jwkKey = generateAndWriteJWKKey(bindingConsentEmptyClaimJWK); + settriggerESignetKeyGen9(false); + } else { + jwkKey = getJWKKey(bindingConsentEmptyClaimJWK); + } + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTEMPTYCLAIMJWKKEY$", jwkKey); + } if (jsonString.contains("$OIDCJWKKEY$")) { String jwkKey = ""; @@ -3154,6 +3180,11 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTVIDSAMECLAIM$", generateWLAToken(jsonString, bindingConsentVidSameClaimJWK, bindingCertConsentVidSameClaimFile)); } + + if (jsonString.contains("$WLATOKENCONSENTEMPTYCLAIM$")) { + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTEMPTYCLAIM$", + generateWLAToken(jsonString, bindingConsentEmptyClaimJWK, bindingCertConsentEmptyClaimFile)); + } if (jsonString.contains("$UINCODECHALLENGEPOS1$")) { jsonString = replaceKeywordWithValue(jsonString, "$UINCODECHALLENGEPOS1$", diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml index 3351d66273b..c385067ebf5 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/GenerateLinkCodeConsent/GenerateLinkCodeConsent.yml @@ -29,4 +29,20 @@ GenerateLinkCodeConsent: }' output: '{ +}' + + ESignet_GenerateLinkCode_Consent_uin_EmptyClaim_all_Valid_Smoke_sid: + endPoint: /v1/esignet/linked-authorization/link-code + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/GenerateLinkCode/GenerateLinkCode + outputTemplate: esignet/GenerateLinkCode/GenerateLinkCodeResult + input: '{ + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_LinkAuth_Consent_EmptyClaim_Valid_Smoke_sid_transactionId$" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml index 53f2b8deeef..ba9f29299ae 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/GetLinkStatusConsent/GetLinkStatusConsent.yml @@ -31,4 +31,21 @@ GetLinkStatusConsent: }' output: '{ +}' + + ESignet_GetLinkStatus_Consent_uin_EmptyClaim_all_Valid_Smoke: + endPoint: /v1/esignet/linked-authorization/link-status + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/GetLinkStatus/GetLinkStatus + outputTemplate: esignet/GetLinkStatus/GetLinkStatusResult + input: '{ + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_LinkAuth_Consent_EmptyClaim_Valid_Smoke_sid_transactionId$", + "linkCode": "$ID:GenerateLinkCode_Consent_uin_EmptyClaim_all_Valid_Smoke_sid_linkCode$" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml index 73d347c6f17..7bc1da1fff9 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkTransactionConsent/LinkTransactionConsent.yml @@ -29,4 +29,20 @@ LinkTransactionConsent: }' output: '{ +}' + + ESignet_LinkTransaction_Consent_uin_EmptyClaim_all_Valid_Smoke_sid: + endPoint: /v1/esignet/linked-authorization/link-transaction + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/LinkTransaction/LinkTransaction + outputTemplate: esignet/LinkTransaction/LinkTransactionResult + input: '{ + "requestTime": "$TIMESTAMP$", + "linkCode": "$ID:GenerateLinkCode_Consent_uin_EmptyClaim_all_Valid_Smoke_sid_linkCode$" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml index 7aaf42045ae..10516b81874 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWla.yml @@ -99,4 +99,55 @@ LinkedAuthenticationConsentWla: "validateOtpResp":{ "sendOtpResTemplate":"esignet/WalletBinding/WalletBindingResult" } +}' + + ESignet_LinkedAuthenticationWla_Consent_EmptyClaim_uin_SCert_all_Valid_Smoke_sid: + endPoint: /v1/esignet/linked-authorization/v2/authenticate + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla + outputTemplate: esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWlaResult + input: '{ + "requestTime": "$TIMESTAMP$", + "linkTransactionId": "$ID:LinkTransaction_Consent_uin_EmptyClaim_all_Valid_Smoke_sid_linkTransactionId$", + "individualId": "$ID:AddIdentity_Linked_Consent_smoke_Pos_UIN$", + "authFactorType": "WLA", + "challenge": "$WLATOKENCONSENTEMPTYCLAIM$", + "format": "jwt", + "sendOtp":{ + "apiKey": "$ID:GenerateApiKey_Valid_Smoke_sid_apiKey$", + "partnerId": "$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Linked_Consent_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendBindingOtp/SendBindingOtp", + "sendOtpEndPoint": "/v1/esignet/binding/binding-otp", + }, + "validateOtp":{ + "apiKey": "$ID:GenerateApiKey_Valid_Smoke_sid_apiKey$", + "partnerId": "$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Linked_Consent_smoke_Pos_UIN$", + "authFactorType1": "WLA", + "format1": "jwt", + "authFactorType": "OTP", + "challenge": "$ID:AddIdentity_Linked_Consent_smoke_Pos_EMAIL$", + "format": "alpha-numeric", + "publicKey": "$BINDINGCONSENTEMPTYCLAIMJWKKEY$", + "validateOtpReqTemplate": "esignet/WalletBinding/WalletBinding", + "validateOtpEndPoint": "/v1/esignet/binding/wallet-binding" + } +}' + output: '{ + "consentAction": "CAPTURE", + "sendOtpResp":{ + "maskedMobile": "$IGNORE$", + "sendOtpResTemplate":"esignet/SendBindingOtp/SendBindingOtpResult", + "maskedEmail": "$IGNORE$" + }, + "validateOtpResp":{ + "sendOtpResTemplate":"esignet/WalletBinding/WalletBindingResult" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml index 78866adf712..65bfa87bba0 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/OAuthDetailsRequestLinkedConsent/OAuthDetailsRequestLinkedConsent.yml @@ -45,4 +45,28 @@ OAuthDetailsRequestLinkedConsent: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_LinkAuth_Consent_EmptyClaim_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/oauth-details + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestNoClaims + outputTemplate: esignet/OAuthDetailsRequest/OAuthDetailsRequestResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "openid resident-service profile", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:linked-wallet", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNoClaims.hbs b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNoClaims.hbs new file mode 100644 index 00000000000..a2170306498 --- /dev/null +++ b/automationtests/src/main/resources/esignet/OAuthDetailsRequest/OAuthDetailsRequestNoClaims.hbs @@ -0,0 +1,16 @@ +{ + "requestTime": "{{requestTime}}", + "request": { + "clientId": "{{clientId}}", + "scope": "{{scope}}", + "responseType": "{{responseType}}", + "redirectUri": "{{redirectUri}}", + "display": "{{display}}", + "prompt": "{{prompt}}", + "acrValues": "{{acrValues}}", + "claims": {}, + "nonce": "{{nonce}}", + "state": "{{state}}", + "claimsLocales": "{{claimsLocales}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml index 14ecb4f64fb..4587f4aed58 100644 --- a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml +++ b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml @@ -246,7 +246,7 @@ SendBindingOtp: validityCheckRequired: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp - outputTemplate: esignet/error + outputTemplate: esignet/SendBindingOtp/SendBindingOtpResult input: '{ "apiKey": "$ID:GenerateApiKey_Valid_Smoke_sid_apiKey$", "partnerId": "$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$", @@ -255,12 +255,8 @@ SendBindingOtp: "otpChannels": [{channel: "email"},{channel: "phone"}] }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" - } - ] + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendBindingOtp_uin_NR_Phone_IndividualId_Neg: @@ -269,7 +265,7 @@ SendBindingOtp: validityCheckRequired: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp - outputTemplate: esignet/error + outputTemplate: esignet/SendBindingOtp/SendBindingOtpResult input: '{ "apiKey": "$ID:GenerateApiKey_Valid_Smoke_sid_apiKey$", "partnerId": "$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$", @@ -278,12 +274,8 @@ SendBindingOtp: "otpChannels": [{channel: "email"},{channel: "phone"}] }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" - } - ] + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendBindingOtp_uin_Missing_IndividualId_Neg: diff --git a/automationtests/src/main/resources/esignet/SendOtp/SendOtp.yml b/automationtests/src/main/resources/esignet/SendOtp/SendOtp.yml index 4f068722e6c..a7a352cb32d 100644 --- a/automationtests/src/main/resources/esignet/SendOtp/SendOtp.yml +++ b/automationtests/src/main/resources/esignet/SendOtp/SendOtp.yml @@ -24,7 +24,7 @@ SendOtp: restMethod: post validityCheckRequired: true inputTemplate: esignet/SendOtp/SendOtp - outputTemplate: esignet/error + outputTemplate: esignet/SendOtp/SendOtpResult input: '{ "encodedHash": "$ID:OAuthDetailsRequest_Other_Valid_Smoke_sid_encodedResp$", "requestTime": "$TIMESTAMP$", @@ -33,12 +33,8 @@ SendOtp: "otpChannels": [{channel: "email"},{channel: "phone"}] }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" - } - ] + "maskedEmail": "$IGNORE$", + "maskedMobile": "XXXXXX3210" }' ESignet_SendOtp_NR_Phone_Uin_Neg: @@ -47,7 +43,7 @@ SendOtp: restMethod: post validityCheckRequired: true inputTemplate: esignet/SendOtp/SendOtp - outputTemplate: esignet/error + outputTemplate: esignet/SendOtp/SendOtpResult input: '{ "encodedHash": "$ID:OAuthDetailsRequest_Other_Valid_Smoke_sid_encodedResp$", "requestTime": "$TIMESTAMP$", @@ -56,12 +52,8 @@ SendOtp: "otpChannels": [{channel: "email"},{channel: "phone"}] }' output: '{ - "errors": [ - { - "errorCode": "IDA-MLC-009", - "errorMessage": "$IGNORE$" - } - ] + "maskedEmail": "$IGNORE$", + "maskedMobile": "$IGNORE$" }' ESignet_SendOtp_Vid_all_Valid_Smoke: From 45bfb331d7b1179aaaef0dc1baecc30658bbad78 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 20 Sep 2023 18:51:13 +0530 Subject: [PATCH 156/204] MOSIP-29517 --- .../GetAppointmentDetails.yml | 18 +++ .../main/resources/preReg/SendOtp/SendOtp.yml | 121 ++++++++++++++++++ .../preReg/UpdateDocRefID/UpdateDocRefID.yml | 40 ++++++ .../preReg/ValidateOtp/ValidateOtp.yml | 88 +++++++++++++ .../preReg/createPrereg/createPrereg.yml | 52 ++++++++ 5 files changed, 319 insertions(+) diff --git a/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml b/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml index d4ef1efeb83..c3cd9f81772 100644 --- a/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml +++ b/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml @@ -23,6 +23,24 @@ GetAppointmentDetails: output: '{ "registration_center_id": "10003" }' + + Prereg_GetAppointmentDetails_Canceled_Application_sid: + endPoint: /preregistration/v1/appointment/{preRegistrationId} + role: batch + restMethod: get + inputTemplate: preReg/GetAppointmentDetails/getAppointmentDetails + outputTemplate: preReg/GetAppointmentDetails/getAppointmentDetailsResult + input: '{ + "preRegistrationId": "$ID:CreatePrereg_Smoke_CancellAppointment_sid_preRegistrationId$" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_APP_013" + } + ] +}' + Prereg_GetAppointmentDetails_inValid_preRegistrationId: endPoint: /preregistration/v1/appointment/{preRegistrationId} role: batch diff --git a/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml b/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml index fc6ce429857..5e7968946a9 100644 --- a/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml +++ b/automationtests/src/main/resources/preReg/SendOtp/SendOtp.yml @@ -14,6 +14,67 @@ SendOtp: output: '{ "status": "success" }' + + Prereg_SendOtp_Invalid_Phone_Neg: + endPoint: /preregistration/v1/login/sendOtp/langcode + role: batch + restMethod: post + inputTemplate: preReg/SendOtp/sendotp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "12", + "id": "mosip.pre-registration.login.sendotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_008" + } + ] +}' + + Prereg_SendOtp_MISSING_Phone_Neg: + endPoint: /preregistration/v1/login/sendOtp/langcode + role: batch + restMethod: post + inputTemplate: preReg/SendOtp/sendotp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "$REMOVE$", + "id": "mosip.pre-registration.login.sendotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_008" + } + ] +}' + + Prereg_SendOtp_SpacialCharacter_Val_Phone_Neg: + endPoint: /preregistration/v1/login/sendOtp/langcode + role: batch + restMethod: post + inputTemplate: preReg/SendOtp/sendotp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "974$%26", + "id": "mosip.pre-registration.login.sendotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_008" + } + ] +}' + Prereg_SendOtp_All_Valid_Smoke_email_sid: endPoint: /preregistration/v1/login/sendOtp/langcode role: batch @@ -28,4 +89,64 @@ SendOtp: }' output: '{ "status": "success" +}' + + Prereg_SendOtp_Invalid__email_Neg: + endPoint: /preregistration/v1/login/sendOtp/langcode + role: batch + restMethod: post + inputTemplate: preReg/SendOtp/sendotp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "jo32", + "id": "mosip.pre-registration.login.sendotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_008" + } + ] +}' + + Prereg_SendOtp_Missing_email_Neg: + endPoint: /preregistration/v1/login/sendOtp/langcode + role: batch + restMethod: post + inputTemplate: preReg/SendOtp/sendotp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "$REMOVE$", + "id": "mosip.pre-registration.login.sendotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_008" + } + ] +}' + + Prereg_SendOtp_SpacialCharacter_email_Neg: + endPoint: /preregistration/v1/login/sendOtp/langcode + role: batch + restMethod: post + inputTemplate: preReg/SendOtp/sendotp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "$!&", + "id": "mosip.pre-registration.login.sendotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_008" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml b/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml index 234164c410f..8ca0d9fda82 100644 --- a/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml +++ b/automationtests/src/main/resources/preReg/UpdateDocRefID/UpdateDocRefID.yml @@ -72,4 +72,44 @@ UpdateDocRefID: "errorCode": "PRG_PAM_DOC_005" } ] +}' + + Prereg_UpdateDocRefID_All_SpatialCharacter_RefNum_Neg: + endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} + role: batch + checkErrorsOnlyInResponse: true + restMethod: put + inputTemplate: preReg/UpdateDocRefID/updateDocRefID + outputTemplate: preReg/error + input: '{ + "documentId": "89jsn$!", + "preRegistrationId": "$ID:CreatePrereg_All_Valid_Smoke_UpdateDocRefID_sid_preRegistrationId$", + "refNumber":"text" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_DOC_005" + } + ] +}' + + Prereg_UpdateDocRefID_Exceeding_Limit_RefNum_Neg: + endPoint: /preregistration/v1/documents/document/{documentId}?preRegistrationId={preRegistrationId}&refNumber={refNumber} + role: batch + checkErrorsOnlyInResponse: true + restMethod: put + inputTemplate: preReg/UpdateDocRefID/updateDocRefID + outputTemplate: preReg/error + input: '{ + "documentId": "qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnm", + "preRegistrationId": "$ID:CreatePrereg_All_Valid_Smoke_UpdateDocRefID_sid_preRegistrationId$", + "refNumber":"text" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_DOC_005" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml b/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml index 7613d01f354..9303967830c 100644 --- a/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml +++ b/automationtests/src/main/resources/preReg/ValidateOtp/ValidateOtp.yml @@ -15,6 +15,51 @@ ValidateOtp: }' output: '{ }' + + Prereg_ValidateOtp_Invalid_Phone_Neg: + endPoint: /preregistration/v1/login/validateOtp + role: batch + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: preReg/ValidateOtp/validateOtp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "909", + "otp": "111111", + "id": "mosip.pre-registration.login.useridotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_013" + } + ] +}' + + Prereg_ValidateOtp_SpacialCharacters_Phone_Neg: + endPoint: /preregistration/v1/login/validateOtp + role: batch + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: preReg/ValidateOtp/validateOtp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "$!(", + "otp": "111111", + "id": "mosip.pre-registration.login.useridotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_013" + } + ] +}' + Prereg_SendOtp_All_Valid_Smoke_email_sid: endPoint: /preregistration/v1/login/validateOtp role: batch @@ -30,4 +75,47 @@ ValidateOtp: "id": "mosip.pre-registration.login.useridotp" }' output: '{ +}' + + Prereg_ValidateOtp_SpacialCharacters_Email_Neg: + endPoint: /preregistration/v1/login/validateOtp + role: batch + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: preReg/ValidateOtp/validateOtp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "john.doe@mail$!inator.com", + "otp": "111111", + "id": "mosip.pre-registration.login.useridotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_013" + } + ] +}' + Prereg_ValidateOtp_Invalid_Email_Neg: + endPoint: /preregistration/v1/login/validateOtp + role: batch + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: preReg/ValidateOtp/validateOtp + outputTemplate: preReg/error + input: '{ + "version": "1.0", + "requesttime": "$TIMESTAMP$", + "userId": "joh23", + "otp": "111111", + "id": "mosip.pre-registration.login.useridotp" +}' + output: '{ + "errors": [ + { + "errorCode": "PRG_PAM_LGN_013" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml index f3238dbe017..0dde123bc62 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml +++ b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml @@ -403,4 +403,56 @@ CreatePrereg: "errorCode": "PRG_CORE_REQ_002" } ] +}' + + Prereg_CreatePrereg_Invalid_PostalCode_Neg: + endPoint: /preregistration/v1/applications/prereg + role: batch + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: preReg/createPrereg/createPrereg + outputTemplate: preReg/error + input: '{ + "postalCode": "14", + "phone": "8249742850", + "email": "goku@technoforte.co.in", + "IDSchemaVersion": $SCHEMAVERSION$, + "dateOfBirth": "1996/01/01", + "version": "1.0", + "langCode": "$1STLANG$", + "requesttime": "$TIMESTAMP$", + "id": "mosip.pre-registration.demographic.create" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-IOV-004" + } + ] +}' + + Prereg_CreatePrereg_SpacialCharacter_PostalCode_Neg: + endPoint: /preregistration/v1/applications/prereg + role: batch + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: preReg/createPrereg/createPrereg + outputTemplate: preReg/error + input: '{ + "postalCode": "$34!", + "phone": "8249742850", + "email": "goku@technoforte.co.in", + "IDSchemaVersion": $SCHEMAVERSION$, + "dateOfBirth": "1996/01/01", + "version": "1.0", + "langCode": "$1STLANG$", + "requesttime": "$TIMESTAMP$", + "id": "mosip.pre-registration.demographic.create" +}' + output: '{ + "errors": [ + { + "errorCode": "KER-IOV-004" + } + ] }' \ No newline at end of file From f232ff2658dce29bbcf655c0beaa70bb7eb34d29 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 20 Sep 2023 18:58:54 +0530 Subject: [PATCH 157/204] resolve --- .../GetAppointmentDetails.yml | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml b/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml index c3cd9f81772..01341040ef5 100644 --- a/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml +++ b/automationtests/src/main/resources/preReg/GetAppointmentDetails/GetAppointmentDetails.yml @@ -24,23 +24,6 @@ GetAppointmentDetails: "registration_center_id": "10003" }' - Prereg_GetAppointmentDetails_Canceled_Application_sid: - endPoint: /preregistration/v1/appointment/{preRegistrationId} - role: batch - restMethod: get - inputTemplate: preReg/GetAppointmentDetails/getAppointmentDetails - outputTemplate: preReg/GetAppointmentDetails/getAppointmentDetailsResult - input: '{ - "preRegistrationId": "$ID:CreatePrereg_Smoke_CancellAppointment_sid_preRegistrationId$" -}' - output: '{ - "errors": [ - { - "errorCode": "PRG_APP_013" - } - ] -}' - Prereg_GetAppointmentDetails_inValid_preRegistrationId: endPoint: /preregistration/v1/appointment/{preRegistrationId} role: batch From f0b6fa91d325bb94b0a38bbaabfc92dcbc609ed6 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 20 Sep 2023 19:24:40 +0530 Subject: [PATCH 158/204] MOSIP-29286 --- .../testscripts/MultiFactorAuthNew.java | 10 + .../resources/ida/AddIdentity/AddIdentity.yml | 27 ++ .../ida/BioAuthHotListPartner/BioAuth.hbs | 34 +++ .../ida/BioAuthHotListPartner/BioAuth.yml | 253 ++++++++++++++++++ .../BioAuthHotListPartner/BioAuthResult.hbs | 9 + .../ida/BioAuthHotListPartner/error.hbs | 17 ++ .../ida/BioAuthHotListPartner/errorKyc.hbs | 9 + .../ida/BlockHotlistAPI/BlockHotlistAPI.yml | 15 ++ .../ida/MultiFactorAuth/MultiFactorAuth.yml | 72 +++++ .../testNgXmlFiles/authenticationApi.xml | 7 + 10 files changed, 453 insertions(+) create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.hbs create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.yml create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuthResult.hbs create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListPartner/error.hbs create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListPartner/errorKyc.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java index ba687108cdc..2f247f3bfda 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java @@ -156,6 +156,16 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) throw new AdminTestException("Failed at Send OTP output validation"); + + if(testCaseDTO.getTestCaseName().contains("expiredOTP")) { + try { + Thread.sleep(Long.parseLong(properties.getProperty("expireOtpTime"))); + } catch (NumberFormatException e) { + logger.error("Exception : " + e.getMessage()); + } catch (InterruptedException e) { + logger.error("Exception : " + e.getMessage()); + } + } String endPoint = testCaseDTO.getEndPoint(); endPoint = uriKeyWordHandelerUri(endPoint, testCaseName); diff --git a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml index 4b86eb6a749..c460dd00a2c 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml @@ -850,4 +850,31 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + auth_AddIdentity_hotlist_UIN_forever_smoke_sid_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + regenerateHbs: true + restMethod: post + inputTemplate: ida/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: ida/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1970/07/08", + "postalCode": "14022", + "email": "auth_AddIdentity_Positive_demoauth_name_smoke@mosip.net", + "phone": "7019858531", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.hbs b/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.hbs new file mode 100644 index 00000000000..ac818dc8d78 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.hbs @@ -0,0 +1,34 @@ +{ + "biometrics": [ + { + "data": { + "bioSubType": "{{bioSubType}}", + "bioType": "{{bioType}}", + "bioValue": "{{bioValue}}" , + "deviceCode": "{{deviceCode}}", + "deviceProviderID": "{{deviceProviderID}}", + "deviceServiceID": "{{deviceServiceID}}", + "deviceServiceVersion": "{{deviceServiceVersion}}", + "env": "Staging", + "domainUri": "https://qa-triple.mosip.net", + "digitalId": { + "serialNo": "{{serialNo}}", + "make": "{{make}}", + "model": "{{model}}", + "type": "{{type}}", + "deviceSubType": "{{deviceSubType}}", + "deviceProvider": "{{deviceProvider}}", + "deviceProviderId": "{{deviceProviderId}}", + "dateTime": "{{dateTime}}" + }, + "mosipProcess": "Auth", + "purpose": "Auth", + "qualityScore": 70, + "requestedScore": 70, + "timestamp": "{{timestamp}}", + "transactionId": "{{transactionId}}" + } + } + ], + "timestamp": "{{timestamp}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.yml b/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.yml new file mode 100644 index 00000000000..2c39b7bc8ae --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuth.yml @@ -0,0 +1,253 @@ +BioAuth: + auth_BioAuth_Biometric_Face_With_blocked_Partner_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_Face_With_BLocked_partner_vid_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/error + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_RingFinger_With_blocked_partner: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/error + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_LeftIndexFingerr_With_blocked_partner: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/error + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_BioAuth_Biometric_IRIS_With_blocked_partner: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/error + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" +}' + auth_EkycBio_Face_With_blocked_partner: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/errorKyc + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_RingFinger_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/errorKyc + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_LeftMiddleFingerr_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/errorKyc + input: '{ + "bioSubType": "Left MiddleFinger", + "bioType": "Finger", + "bioValue": "$LEFTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' + auth_EkycBio_RIGHTIRIS_With_blocked_deviceProviderId: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListPartner/BioAuth + outputTemplate: ida/BioAuthHotListPartner/errorKyc + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "571203", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "false" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuthResult.hbs b/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuthResult.hbs new file mode 100644 index 00000000000..1c86da21a83 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListPartner/BioAuthResult.hbs @@ -0,0 +1,9 @@ +{ + "authResponse": { + "body": { + "response": { + "authStatus": "{{authStatus}}" + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListPartner/error.hbs b/automationtests/src/main/resources/ida/BioAuthHotListPartner/error.hbs new file mode 100644 index 00000000000..3ae04f7cbac --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListPartner/error.hbs @@ -0,0 +1,17 @@ +{ + "authResponse": { + "body": { + "errors": [ + {{#each errors}} + { + "errorCode": "{{errorCode}}" + } + {{#unless @last}},{{/unless}} + {{/each}} + ], + "response": { + "authStatus": {{authStatus}} + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListPartner/errorKyc.hbs b/automationtests/src/main/resources/ida/BioAuthHotListPartner/errorKyc.hbs new file mode 100644 index 00000000000..9d51fe4b7fb --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListPartner/errorKyc.hbs @@ -0,0 +1,9 @@ +{ + "authResponse": { + "body": { + "response": { + "kycStatus": {{kycStatus}} + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml b/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml index 269fac266bc..3178e29cdea 100644 --- a/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml +++ b/automationtests/src/main/resources/ida/BlockHotlistAPI/BlockHotlistAPI.yml @@ -10,6 +10,21 @@ HotlistAPI: "idType": "UIN", "requestTime": "$TIMESTAMP$", "expiryTimestamp": "" + }' + output: '{ + "status": "BLOCKED" + }' + auth_BlockHotlistAPI_All_Valid_Smoke_UIN_forever_sid: + endPoint: /v1/hotlist/block + role: hotlist + restMethod: post + inputTemplate: ida/BlockHotlistAPI/blockHotlistAPI + outputTemplate: ida/BlockHotlistAPI/blockHotlistAPIResult + input: '{ + "id": "$ID:AddIdentity_hotlist_UIN_forever_smoke_sid_Pos_UIN$", + "idType": "UIN", + "requestTime": "$TIMESTAMP$", + "expiryTimestamp": "" }' output: '{ "status": "BLOCKED" diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml index 869067e50df..9ed2d86ae57 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml @@ -2481,4 +2481,76 @@ MultiFactorAuth: "sendOtpResp":{ "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" } +}' + auth_MultiFactorAuth_Biometric_Face_With_Valid_uin_expiredOTP_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/MultiFactorAuth/MultiFactorAuth + outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult + input: '{ + "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "key": "dob", + "value": "1970/07/08", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "true", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" + } +}' + auth_MultiFactorAuth_Biometric_Face_With_Valid_uin_expiredOTP_EKYCBIO_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/MultiFactorAuth/MultiFactorAuth + outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult + input: '{ + "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_ValidParam_smoke_Pos_UIN$", + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "key": "dob", + "value": "1970/07/08", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "true", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/MultiFactorAuth/sendOtpRes" + } }' \ No newline at end of file diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index a21b6db10fb..323f8091b99 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -246,6 +246,13 @@ + + + + + + Date: Wed, 20 Sep 2023 20:23:40 +0530 Subject: [PATCH 159/204] MOSIP-29513 --- .../AuthenticateUserVCI.yml | 594 ------------- .../AuthorizationCodeVCI.yml | 318 ------- .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 260 ------ .../VCI/GetCredential/GetCredential.yml | 541 ------------ .../OAuthDetailsRequestVCI.yml | 782 ------------------ .../AuthenticateUserVCI.hbs | 15 + .../AuthenticateUserVCI.yml | 594 +++++++++++++ .../AuthenticateUserVCIResult.hbs | 1 + .../AuthorizationCodeVCI.hbs | 19 + .../AuthorizationCodeVCI.yml | 318 +++++++ .../AuthorizationCodeVCIResult.hbs | 1 + .../GenerateTokenVCI/GenerateTokenVCI.hbs | 9 + .../GenerateTokenVCI/GenerateTokenVCI.yml | 260 ++++++ .../GenerateTokenVCIResult.hbs | 3 + .../VCINegTC/GetCredential/GetCredential.hbs | 23 + .../VCINegTC/GetCredential/GetCredential.yml | 541 ++++++++++++ .../GetCredentialEmptyCredDef.hbs | 10 + .../GetCredential/GetCredentialNoCredDef.hbs | 10 + .../GetCredential/GetCredentialNoProof.hbs | 19 + .../GetCredential/GetCredentialResult.hbs | 1 + .../OAuthDetailsRequestVCI.hbs | 17 + .../OAuthDetailsRequestVCI.yml | 782 ++++++++++++++++++ .../OAuthDetailsRequestVCIResult.hbs | 1 + .../testNgXmlFiles/esignetSuite.xml | 38 + 24 files changed, 2662 insertions(+), 2495 deletions(-) create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialEmptyCredDef.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoCredDef.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoProof.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index 3431493c98a..48cdf9d92d3 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -30,598 +30,4 @@ AuthenticateUserVCI: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen1_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen2_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen3_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen4_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_Diff_Scope_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen1_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen2_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen3_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_Hash_CodeChallenge_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen1_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen2_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen3_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen4_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen5_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen6_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen7_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen8_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - - ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen9_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 19f3d7f9481..4f7ebe91178 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -13,322 +13,4 @@ AuthorizationCodeVCI: "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid_transactionId$" }' output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_Invalid_Scope: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/error - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", - "permittedAuthorizeScopes": [{scope: "sdfsfd"}] -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_permitted_scope" - } - ] -}' - - ESignet_AuthorizationCode_VCI_uin_Empty_Scope: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/error - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", - "permittedAuthorizeScopes": [{scope: ""}] -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_permitted_scope" - } - ] -}' - - ESignet_AuthorizationCode_VCI_uin_Invalid_Comma_Separated_Scope: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/error - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", - "permittedAuthorizeScopes": [{scope: "sdfaf, asdf"}] -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_permitted_scope" - } - ] -}' - - ESignet_AuthorizationCode_VCI_uin_Invalid_Diff_Scope: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/error - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", - "permittedAuthorizeScopes": [{scope: "mosip_identity_vc_ldp"}] -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_permitted_scope" - } - ] -}' - - ESignet_AuthorizationCode_VCI_uin_Invalid_Claim_Neg: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/error - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", - "acceptedClaims": [{claim: "name"}] -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_accepted_claim" - } - ] -}' - - ESignet_AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegTokenScen2_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegTokenScen3_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen1_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen2_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen3_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen4_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen5_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen6_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen7_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen8_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - - ESignet_AuthorizationCode_VCI_uin_NegCredScen9_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$" -}' - output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index bdfbebc2546..636032b5f70 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -17,264 +17,4 @@ GenerateTokenVCI: }' output: '{ "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegTokenScen1_Invalid_code_verifier: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/error2 - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "sdgfhss" -}' - output: '{ - "error": "pkce_failed" -}' - - ESignet_GenerateTokenVCI_uin_NegTokenScen2_Empty_code_verifier: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/error2 - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen2_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "" -}' - output: '{ - "error": "invalid_pkce_code_verifier" -}' - - ESignet_GenerateTokenVCI_uin_NegTokenScen3_NoHash_code_verifier: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/error2 - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen3_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" -}' - output: '{ - "error": "pkce_failed" -}' - - ESignet_GenerateTokenVCI_uin_Invalid_Hash_CodeChallenge: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/error2 - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "error": "pkce_failed" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen1_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen1_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen2_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen2_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen3_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen3_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen4_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen4_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen5_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen5_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen6_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen6_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen7_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen7_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen8_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen8_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - - ESignet_GenerateTokenVCI_uin_NegCredScen9_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen9_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index d4e865618d3..1bb58dc28b8 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -17,545 +17,4 @@ GetCredential: "proof_jwt": "$PROOFJWT$" }' output: '{ -}' - - ESignet_GetCredential_uin_IdpAccessToken_NegCredScen1_Invalid_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen1_Smoke_sid_access_token$", - "format": "dfsfd", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error":"unsupported_credential_format" -}' - - ESignet_GetCredential_uin_IdpAccessToken_NegCredScen2_Invalid_Proof_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen2_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "wewrt" -}' - output: '{ - "error":"invalid_proof" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen3_Smoke_sid_access_token$", - "format": "$REMOVE$", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_vc_format" -}' - - ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen4_Smoke_sid_access_token$", - "format": " ", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_vc_format" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Empty_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen5_Smoke_sid_access_token$", - "format": "", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_vc_format" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Inval1_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen6_Smoke_sid_access_token$", - "format": "jwt_vc_json", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unknown_error" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Inval2_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen7_Smoke_sid_access_token$", - "format": "jwt_vc_json-ld", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unknown_error" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Inval3_Format_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen8_Smoke_sid_access_token$", - "format": "ldp_vc, jwt_vc_json-ld", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_credential_format" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredentialNoCredDef - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "credential_definition" : "$REMOVE$", - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_request" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Empty_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredentialEmptyCredDef - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_request" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Empty_Cred_Def_Value_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: ""}, {types: ""}], - "@context": [{context: ""}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_request" -}' - - ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: " "}, {types: " "}], - "@context": [{context: " "}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_request" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Mandate_Val1_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_credential_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Mandate_Val2_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_credential_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Empty_Context_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: ""}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "invalid_request" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Inval_Val_Cred_Def_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "sfsdf"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_credential_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredentialNoProof - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}] -}' - output: '{ - "error": "invalid_proof" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Val_Proof_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "$REMOVE$", - "proof_jwt": "$REMOVE$" -}' - output: '{ - "error": "unsupported_proof_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Type_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "$REMOVE$", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_proof_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Empty_Proof_Type_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_proof_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Proof_Type_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": " ", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_proof_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Invalid_Proof_Type_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "dfgdfg", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ - "error": "unsupported_proof_type" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Val_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$REMOVE$" -}' - output: '{ - "error": "invalid_proof" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Empty_Proof_Val_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "" -}' - output: '{ - "error": "invalid_proof" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Space_Proof_Val_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": " " -}' - output: '{ - "error": "invalid_proof" -}' - - ESignet_GetCredential_uin_IdpAccessToken_Invalid_Proof_Val_Neg: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/error2 - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "sdfs" -}' - output: '{ - "error": "invalid_proof" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index 9193f6b1f85..98198686a10 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -23,786 +23,4 @@ OAuthDetailsRequestVCI: }' output: '{ -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Empty_Scope_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_scope" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Diff_Scope_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "openid profile", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Scope_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "openid profile, mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_scope" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Code_Challenge_Method_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "sdgfdg" -}' - output: '{ - "errors": [ - { - "errorCode": "unsupported_pkce_challenge_method" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Empty_Code_Challenge_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "", - "codeChallengeMethod": "S256" -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_pkce_challenge" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Empty_Code_Challenge_Method_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "" -}' - output: '{ - "errors": [ - { - "errorCode": "unsupported_pkce_challenge_method" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Long_Code_Challenge_Pos: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Missing_Code_Challenge_Pos: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$REMOVE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Missing_Code_Challenge_Method_Pos: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "$REMOVE$" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Missing_Code_Challenge_And_Method_Pos: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$REMOVE$", - "codeChallengeMethod": "$REMOVE$" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Val_Scope_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "hafkja", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_scope" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_Missing_Scope_Neg: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/error - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "$REMOVE$", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - "errors": [ - { - "errorCode": "invalid_scope" - } - ] -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - -}' - - ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs new file mode 100644 index 00000000000..887633e1120 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs @@ -0,0 +1,15 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "individualId": "{{individualId}}", + "challengeList" : [ + { + "authFactorType" : "{{authFactorType}}", + "challenge" : "{{challenge}}", + "format": "alpha-numeric" + } + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml new file mode 100644 index 00000000000..bb5467cfc8d --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -0,0 +1,594 @@ +AuthenticateUserVCINegTC: + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen1_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen4_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_Diff_Scope_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen1_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegTokenScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_Hash_CodeChallenge_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen1_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen4_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen5_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen6_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen7_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen8_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegCredScen9_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs new file mode 100644 index 00000000000..491dca1ba1f --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs @@ -0,0 +1,19 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "acceptedClaims": [ + {{#each acceptedClaims}} + "{{claim}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "permittedAuthorizeScopes": [ + {{#each permittedAuthorizeScopes}} + "{{scope}}" + {{#unless @last}},{{/unless}} + {{/each}} + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml new file mode 100644 index 00000000000..7818765b030 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -0,0 +1,318 @@ +AuthorizationCodeVCINegTC: + ESignet_AuthorizationCode_VCI_uin_Invalid_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "sdfsfd"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Empty_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: ""}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Invalid_Comma_Separated_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "sdfaf, asdf"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Invalid_Diff_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Diff_Scope_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "mosip_identity_vc_ldp"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Invalid_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: "name"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegTokenScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegTokenScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen5_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen6_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen7_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen8_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_NegCredScen9_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.hbs new file mode 100644 index 00000000000..c425e67650b --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.hbs @@ -0,0 +1,9 @@ +{ + "grant_type": "{{grant_type}}", + "code": "{{code}}", + "client_id": "{{client_id}}", + "client_assertion_type": "{{client_assertion_type}}", + "client_assertion": "{{client_assertion}}", + "redirect_uri": "{{redirect_uri}}", + "code_verifier": "{{code_verifier}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.yml new file mode 100644 index 00000000000..da78ebb9ff4 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI.yml @@ -0,0 +1,260 @@ +GenerateTokenVCINegTC: + ESignet_GenerateTokenVCI_uin_NegTokenScen1_Invalid_code_verifier: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen1_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "sdgfhss" +}' + output: '{ + "error": "pkce_failed" +}' + + ESignet_GenerateTokenVCI_uin_NegTokenScen2_Empty_code_verifier: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen2_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "" +}' + output: '{ + "error": "invalid_pkce_code_verifier" +}' + + ESignet_GenerateTokenVCI_uin_NegTokenScen3_NoHash_code_verifier: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegTokenScen3_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" +}' + output: '{ + "error": "pkce_failed" +}' + + ESignet_GenerateTokenVCI_uin_Invalid_Hash_CodeChallenge: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/error2 + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "error": "pkce_failed" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen1_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen1_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen2_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen2_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen3_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen3_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen4_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen4_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen5_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen5_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen6_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen6_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen7_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen7_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen8_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen8_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_NegCredScen9_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_NegCredScen9_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult.hbs new file mode 100644 index 00000000000..c323e20a77e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GenerateTokenVCI/GenerateTokenVCIResult.hbs @@ -0,0 +1,3 @@ +{ + "token_type": "{{token_type}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.hbs new file mode 100644 index 00000000000..74e5e52857d --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.hbs @@ -0,0 +1,23 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : { + "type": [ + {{#each type}} + "{{types}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "@context": [ + {{#each @context}} + "{{context}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + }, + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml new file mode 100644 index 00000000000..26b2ca61f43 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml @@ -0,0 +1,541 @@ +GetCredentialNegTC: + ESignet_GetCredential_uin_IdpAccessToken_NegCredScen1_Invalid_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen1_Smoke_sid_access_token$", + "format": "dfsfd", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"unsupported_credential_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_NegCredScen2_Invalid_Proof_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen2_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "wewrt" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen3_Smoke_sid_access_token$", + "format": "$REMOVE$", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_vc_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen4_Smoke_sid_access_token$", + "format": " ", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_vc_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen5_Smoke_sid_access_token$", + "format": "", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_vc_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval1_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen6_Smoke_sid_access_token$", + "format": "jwt_vc_json", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unknown_error" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval2_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen7_Smoke_sid_access_token$", + "format": "jwt_vc_json-ld", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unknown_error" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval3_Format_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen8_Smoke_sid_access_token$", + "format": "ldp_vc, jwt_vc_json-ld", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_format" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredentialNoCredDef + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "credential_definition" : "$REMOVE$", + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredentialEmptyCredDef + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Cred_Def_Value_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: ""}, {types: ""}], + "@context": [{context: ""}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: " "}, {types: " "}], + "@context": [{context: " "}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Mandate_Val1_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Mandate_Val2_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Context_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: ""}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "invalid_request" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Inval_Val_Cred_Def_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "sfsdf"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_credential_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredentialNoProof + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}] +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Val_Proof_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "$REMOVE$", + "proof_jwt": "$REMOVE$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "$REMOVE$", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": " ", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Proof_Type_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "dfgdfg", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error": "unsupported_proof_type" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$REMOVE$" +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "" +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Space_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": " " +}' + output: '{ + "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Proof_Val_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "sdfs" +}' + output: '{ + "error": "invalid_proof" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialEmptyCredDef.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialEmptyCredDef.hbs new file mode 100644 index 00000000000..5d7d77356e9 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialEmptyCredDef.hbs @@ -0,0 +1,10 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : {}, + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoCredDef.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoCredDef.hbs new file mode 100644 index 00000000000..66fef780c5d --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoCredDef.hbs @@ -0,0 +1,10 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : "{{credential_definition}}", + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoProof.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoProof.hbs new file mode 100644 index 00000000000..761bada3bcf --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialNoProof.hbs @@ -0,0 +1,19 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : { + "type": [ + {{#each type}} + "{{types}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "@context": [ + {{#each @context}} + "{{context}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialResult.hbs b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredentialResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs new file mode 100644 index 00000000000..6dec068b531 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs @@ -0,0 +1,17 @@ +{ + "requestTime": "{{requestTime}}", + "request": { + "clientId": "{{clientId}}", + "scope": "{{scope}}", + "responseType": "{{responseType}}", + "redirectUri": "{{redirectUri}}", + "display": "{{display}}", + "prompt": "{{prompt}}", + "acrValues": "{{acrValues}}", + "nonce" : "{{nonce}}", + "state" : "{{state}}", + "claimsLocales" : "{{claimsLocales}}", + "codeChallenge" : "{{codeChallenge}}", + "codeChallengeMethod" : "{{codeChallengeMethod}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml new file mode 100644 index 00000000000..2f38f8f22ea --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -0,0 +1,782 @@ +OAuthDetailsRequestVCINegTC: + ESignet_OAuthDetailsRequest_VCI_uin_Empty_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Diff_Scope_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "openid profile", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "openid profile, mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Code_Challenge_Method_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "sdgfdg" +}' + output: '{ + "errors": [ + { + "errorCode": "unsupported_pkce_challenge_method" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Empty_Code_Challenge_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_pkce_challenge" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Empty_Code_Challenge_Method_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "" +}' + output: '{ + "errors": [ + { + "errorCode": "unsupported_pkce_challenge_method" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Long_Code_Challenge_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Missing_Code_Challenge_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$REMOVE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Missing_Code_Challenge_Method_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "$REMOVE$" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Missing_Code_Challenge_And_Method_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$REMOVE$", + "codeChallengeMethod": "$REMOVE$" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Hash_CodeChallenge_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Invalid_Val_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "hafkja", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Missing_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "$REMOVE$", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen5_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen6_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen7_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen8_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/testNgXmlFiles/esignetSuite.xml b/automationtests/testNgXmlFiles/esignetSuite.xml index e950b02e35b..52d7f98a630 100644 --- a/automationtests/testNgXmlFiles/esignetSuite.xml +++ b/automationtests/testNgXmlFiles/esignetSuite.xml @@ -468,6 +468,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 6447387f06a354bbed95050df027ffe7f68c77c0 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 21 Sep 2023 10:01:13 +0530 Subject: [PATCH 160/204] changing push report to s3 as yes --- automationtests/src/main/resources/config/Kernel.properties | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 9eefc27e090..c89959eea28 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -202,8 +202,8 @@ s3-account=automation s3-region=null reportExpirationInDays=3 # supported values yes or no -push-reports-to-s3=no -enableDebug=yes +push-reports-to-s3=yes +enableDebug=no # supported values are 1 to 8 threadCount=1 # supported values are 0 ,1, 2 based on number of env languages From 7d45adc3c5ad4104f2b1e6028006b501729f9c3c Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 21 Sep 2023 11:15:29 +0530 Subject: [PATCH 161/204] MOSIP-29454 --- .../mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 14acbba3836..a15d5440ec8 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4061,9 +4061,9 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { String phone = getValueFromAuthActuator("json-property", "phone_number"); String result = phone.replaceAll("\\[\"|\"\\]", ""); - /* - * if (!isElementPresent(objIDJson1, result)) { objIDJson1.put(result); } - */ + if (!isElementPresent(objIDJson1, result)) { + objIDJson1.put(result); + } //System.out.println("result is:" + result); String email = getValueFromAuthActuator("json-property", "emailId"); From 2f4f209e7c4413e3bfcb90fd8b131441001ebf29 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 21 Sep 2023 12:21:05 +0530 Subject: [PATCH 162/204] MOSIP-29454 --- .../apirig/admin/fw/util/AdminTestUtil.java | 18 +++++++- .../main/resources/config/Kernel.properties | 42 ++++++++--------- .../idRepository/AddIdentity/AddIdentity.yml | 45 ++++++++++++++++++- 3 files changed, 81 insertions(+), 24 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index a15d5440ec8..59748697297 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4051,6 +4051,7 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { BufferedReader bufferedReader = null; boolean emailFieldAdditionallyAdded=false; + boolean phoneFieldAdditionallyAdded=false; try { JSONObject jObj = new JSONObject(schemaFile); JSONObject objIDJson4 = jObj.getJSONObject(GlobalConstants.PROPERTIES); @@ -4063,6 +4064,7 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { if (!isElementPresent(objIDJson1, result)) { objIDJson1.put(result); + phoneFieldAdditionallyAdded=true; } //System.out.println("result is:" + result); @@ -4140,8 +4142,20 @@ public static String modifySchemaGenerateHbs(boolean regenerateHbs) { } else if (objIDJson3.equals(result)) { - fileWriter2 - .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + + if(phoneFieldAdditionallyAdded) { + fileWriter2 + .write(",\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + "\n"); + } + else { + fileWriter2 + .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + } + + /* + * fileWriter2 .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + + * objIDJson3 + "}}\"" + ",\n"); + */ } else if (objIDJson3.equals(emailResult)) { diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index c89959eea28..c18617279ed 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -108,48 +108,48 @@ partner_userName=111997 partner_user_password=mosip123 mosip_pms_client_id=mosip-pms-client mosip_partner_client_id=mosip-partner-client -mosip_partner_client_secret=iTdlzpTDXehfiGDm -mosip_pms_client_secret=43EUvwmN87Uq7ouQ +mosip_partner_client_secret=oLXzaUc3nvuk0BwJ +mosip_pms_client_secret=28nu0nKY9dgThCIs policytest_password=mosip123 policytest_userName=111998 #RESIDENT & IDA mosip_resident_app_id=resident mosip_resident_client_id=mosip-resident-client -mosip_resident_client_secret=jGSnSgsErPFNwlmA +mosip_resident_client_secret=QHiANH32pu2ajXwU #IDREPO mosip_idrepo_app_id=idrepo mosip_idrepo_client_id=mosip-idrepo-client -mosip_idrepo_client_secret=GpFzjpxln5BLnkzT +mosip_idrepo_client_secret=1goKToWjb8t6nFeW #admin mosip_admin_app_id=admin admin_password=mosip123 admin_userName=220005 mosip_admin_client_id=mosip-admin-client -mosip_admin_client_secret=c8G64FPSF9YoMFJ2 +mosip_admin_client_secret=f3mZVaYBfuvyfcjJ #admin admin_zone_password=mosip123 admin_zone_userName=globaladmin mosip_regclient_app_id=registrationclient mosip_reg_client_id=mosip-reg-client -mosip_reg_client_secret=JWVbi1IyOrejsLWx +mosip_reg_client_secret=zPnLp4cpbpl3z6LX #admin mosip_regprocclient_app_id=regproc mosip_regproc_client_id=mosip-regproc-client -mosip_regproc_client_secret=OOuk02uHCQdXltAb +mosip_regproc_client_secret=zJfvS0uBfKDuf7NK #mparter_mobile mpartner_default_mobile_client_id=mpartner-default-mobile -mpartner_default_mobile_secret=dGWf50OxU2D5YZor +mpartner_default_mobile_secret=hpKNRdJCL5W3yjoN #This credentials are used to execute auth demo service AuthClientID=mosip-resident-client -AuthClientSecret=jGSnSgsErPFNwlmA +AuthClientSecret=QHiANH32pu2ajXwU AuthAppID=resident mosip_hotlist_app_id=hotlist mosip_hotlist_client_id=mosip-hotlist-client -mosip_hotlist_client_secret=LKRshKECGSCsZ7qZ +mosip_hotlist_client_secret=UNzuUKJDBr3k9BuQ ###Keycloak_User-Creation_Properties #Dontchange the partner user_111997 @@ -162,9 +162,9 @@ roles.111995=PARTNER_ADMIN,default-roles-mosip keycloak_UserName = admin keycloak_Password = QpmcF92Mvp -keycloak-external-url=https://iam.upgrade2.mosip.net +keycloak-external-url=https://iam.qa-upgrade3.mosip.net mosip_testrig_client_id=mosip-testrig-client -mosip_testrig_client_secret=Vvg1357vfq6EFYu4 +mosip_testrig_client_secret=F0nqSasG5fWPpBvG keycloak-realm-id=mosip iam-users-to-create=111997,111998,220005,111992,globaladmin @@ -182,14 +182,14 @@ dialect=org.hibernate.dialect.PostgreSQLDialect show_sql=true current_session_context_class=thread #audit details -audit_url=jdbc:postgresql://upgrade2.mosip.net:5432/mosip_audit +audit_url=jdbc:postgresql://qa-upgrade3.mosip.net:5432/mosip_audit audit_username=postgres audit_password=mosip123 audit_default_schema=audit #ida-partner details DB_PORT= installation-domain= -partner_url=jdbc:postgresql://upgrade2.mosip.net:5432/mosip_ida +partner_url=jdbc:postgresql://qa-upgrade3.mosip.net:5432/mosip_ida partner_username=postgres partner_password=mosip123 partner_default_schema=partner @@ -202,8 +202,8 @@ s3-account=automation s3-region=null reportExpirationInDays=3 # supported values yes or no -push-reports-to-s3=yes -enableDebug=no +push-reports-to-s3=no +enableDebug=yes # supported values are 1 to 8 threadCount=1 # supported values are 0 ,1, 2 based on number of env languages @@ -211,7 +211,7 @@ langselect=0 #----------------------------------Database properties----------------------------------------------------------# postgresqlUser=postgresql db-port=5432 -db-server=upgrade2.mosip.net +db-server=qa-upgrade3.mosip.net hibernate.connection.driver_class=org.postgresql.Driver hibernate.connection.pool_size=1 hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -#authDemoServiceBaseURL=http://localhost -#authDemoServicePort=8082 +authDemoServiceBaseURL=http://localhost +authDemoServicePort=8082 #To run in Docker -authDemoServiceBaseURL=http://authdemo.apitestrig -authDemoServicePort=80 +#authDemoServiceBaseURL=http://authdemo.apitestrig +#authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# diff --git a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml index d4e84de60e3..3acfe9cc9d0 100644 --- a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml @@ -18,6 +18,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -49,6 +50,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -80,6 +82,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -112,6 +115,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -144,6 +148,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -175,6 +180,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -207,6 +213,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -238,6 +245,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -269,6 +277,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -305,6 +314,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "awge", @@ -342,6 +352,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "", @@ -378,6 +389,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": " ", @@ -414,6 +426,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -451,6 +464,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -487,6 +501,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -523,6 +538,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -559,6 +575,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -595,6 +612,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "$REMOVE$", @@ -630,7 +648,8 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", - "phone": "82@@^%#850", + "phone": "473g2b2333##$%^", + "mobileno": "473g2b2333##$%^", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -666,6 +685,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "$REMOVE$", + "mobileno": "$REMOVE$", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -698,6 +718,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "", + "mobileno": "", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -734,6 +755,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": " ", + "mobileno": "", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -770,6 +792,7 @@ AddIdentity: "postalCode": "14022", "email": "sdafa%%$#$%%", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -805,6 +828,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "9876543210111222", + "mobileno": "9876543210111222", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -840,6 +864,7 @@ AddIdentity: "postalCode": "14022", "email": "$REMOVE$", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -872,6 +897,7 @@ AddIdentity: "postalCode": "14022", "email": "", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -908,6 +934,7 @@ AddIdentity: "postalCode": "14022", "email": " ", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -944,6 +971,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -981,6 +1009,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1017,6 +1046,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1053,6 +1083,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1089,6 +1120,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1125,6 +1157,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1161,6 +1194,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1197,6 +1231,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1229,6 +1264,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1261,6 +1297,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1293,6 +1330,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1325,6 +1363,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1357,6 +1396,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1389,6 +1429,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1421,6 +1462,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -1453,6 +1495,7 @@ AddIdentity: "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", + "mobileno": "8249742850", "referenceIdentityNumber": "6789545678878", "version": "v1", From 5a1285a03b6017e659f1c455fce82873461f9c89 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 21 Sep 2023 13:05:55 +0530 Subject: [PATCH 163/204] Update Kernel.properties Signed-off-by: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> --- .../src/main/resources/config/Kernel.properties | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index c18617279ed..8f6bdaee3c5 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -202,7 +202,7 @@ s3-account=automation s3-region=null reportExpirationInDays=3 # supported values yes or no -push-reports-to-s3=no +push-reports-to-s3=yes enableDebug=yes # supported values are 1 to 8 threadCount=1 @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -authDemoServiceBaseURL=http://localhost -authDemoServicePort=8082 +#authDemoServiceBaseURL=http://localhost +#authDemoServicePort=8082 #To run in Docker -#authDemoServiceBaseURL=http://authdemo.apitestrig -#authDemoServicePort=80 +authDemoServiceBaseURL=http://authdemo.apitestrig +authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# @@ -265,4 +265,4 @@ eSignetDeployed=yes scenariosToSkip= -partnerUrlSuffix=oYf63Lax0DY2QkYMRHnrmDqhmO3RMWQagwm0ftgLlkuin1KOND/666/576732 \ No newline at end of file +partnerUrlSuffix=oYf63Lax0DY2QkYMRHnrmDqhmO3RMWQagwm0ftgLlkuin1KOND/666/576732 From 562c4e5d344806ba25b0077c181e71bc4a310654 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 21 Sep 2023 13:47:31 +0530 Subject: [PATCH 164/204] MOSIP-29454 --- .../resources/ida/AddIdentity/AddIdentity.yml | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml index c460dd00a2c..34090b544c1 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml @@ -15,6 +15,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -41,6 +42,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -67,6 +69,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_ValidParam_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -93,6 +96,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_For_Otp_Auth_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -119,6 +123,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_UIN_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -145,6 +150,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_EKYC_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -171,6 +177,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_InternalOTP_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -197,6 +204,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_EKYCOTP_PRE_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -223,6 +231,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_TRE_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -249,6 +258,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_valid_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -275,6 +285,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_UIN_Unlock_BioAuth_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -305,6 +316,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_UIN_Unlock_DemoAuth_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -337,6 +349,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_permanent_BioAuth_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -369,6 +382,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_permanent_DemoAuth_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -401,6 +415,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_unblockUIN_valid_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -433,6 +448,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_LockUIN_valid_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -464,6 +480,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_LockUIN_For_bio_valid_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -495,6 +512,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_EkycDemo_Auth_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -527,6 +545,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_EKYCUIN_valid_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -558,6 +577,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Deactivate_and_auth_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -589,6 +609,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_create_vid_using_uin_for_revoke_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -620,6 +641,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_for_hotlist_id_service_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -652,6 +674,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_UIN_Unlock_BioAuth_withValidParams_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -683,6 +706,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_UIN_Unlock_DemoAuth_withValidParams_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -715,6 +739,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_permanent_BioAuth_withValidParams_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -747,6 +772,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Lock_permanent_DemoAuth_withValidParams_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -779,6 +805,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Valid_Parameters_Auth_smoke_Pos@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -812,6 +839,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_demoauth_name_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", @@ -841,6 +869,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_demoauth_name_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -868,6 +897,7 @@ AddIdentity: "postalCode": "14022", "email": "auth_AddIdentity_Positive_demoauth_name_smoke@mosip.net", "phone": "7019858531", + "mobileno": "7019858531", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", From 9be1d13d1c4a8f5146bcfd2578feec1e214a78d6 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 21 Sep 2023 13:53:49 +0530 Subject: [PATCH 165/204] MOSIP-29454 --- .../resident/AddIdentity/AddIdentity.yml | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml index a1203518156..11b323f6509 100644 --- a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml @@ -15,6 +15,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_withValidParameters_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -41,6 +42,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ValidParam_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -67,6 +69,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Positive_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -93,6 +96,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Positive_PEXP_smoke@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -119,6 +123,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Positive_PDEA_smoke@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -145,6 +150,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Positive_TDEA_smoke@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -171,6 +177,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Positive_PRE_smoke@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -197,6 +204,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Positive_TRE_smoke@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -225,6 +233,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Valid_Params_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -253,6 +262,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Valid_Params_AddUser_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -281,6 +291,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ValidParameters_ChannelVerify_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -308,6 +319,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ValidParams_For_Revoke_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -335,6 +347,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Esignet_Integ_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -362,6 +375,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Esignet_Integ_Vid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -389,6 +403,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_GetRid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -416,6 +431,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_UpdateCount_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -443,6 +459,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ForEotp_Scen_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -470,6 +487,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ForEotp_Scen_Vid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -497,6 +515,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ForEotp_Temp_Vid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -524,6 +543,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_ForEotp_Onetime_Vid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -551,6 +571,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_OrdrSts_Valid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", @@ -578,6 +599,7 @@ AddIdentity: "postalCode": "14022", "email": "Resident_AddIdentity_Invalid_Scen_Vid_smoke_Pos@mosip.net", "phone": "9876543210", + "mobileno": "9876543210", "referenceIdentityNumber": "6789545678878", "version": "v1", "introducerRID": "212124324784879", From 7d7936af1837756bde25178b3d0d3ddda1c57df3 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 21 Sep 2023 19:22:24 +0530 Subject: [PATCH 166/204] MOSIP-29513 --- .../AuthenticateUserVCI.yml | 66 +++++++++++ .../AuthorizationCodeVCI.yml | 32 ++++++ .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 40 +++++++ .../VCI/GetCredential/GetCredential.yml | 40 +++++++ .../OAuthDetailsRequestVCI.yml | 52 +++++++++ .../OAuthDetailsRequestVCI.yml | 104 ++++++++++++++++++ 6 files changed, 334 insertions(+) diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index 48cdf9d92d3..eb2d981ed49 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -30,4 +30,70 @@ AuthenticateUserVCI: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_1stLang_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_2ndLang_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 4f7ebe91178..33f1184f249 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -13,4 +13,36 @@ AuthorizationCodeVCI: "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_all_Valid_Smoke_sid_transactionId$" }' output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_All_1stLang_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_All_2ndLang_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid_transactionId$" +}' + output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index 636032b5f70..a80fc64300b 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -17,4 +17,44 @@ GenerateTokenVCI: }' output: '{ "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_1stLang_Valid_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_All_1stLang_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_uin_2ndLang_Valid_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_uin_All_2ndLang_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index 1bb58dc28b8..be637698ad6 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -17,4 +17,44 @@ GetCredential: "proof_jwt": "$PROOFJWT$" }' output: '{ +}' + + ESignet_GetCredential_uin_IdpAccessToken_1stLang_all_Valid_Smoke: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/VCI/GetCredential/GetCredentialResult + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_1stLang_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ +}' + + ESignet_GetCredential_uin_IdpAccessToken_2ndLang_all_Valid_Smoke: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/VCI/GetCredential/GetCredentialResult + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_2ndLang_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index 98198686a10..4767e52a453 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -23,4 +23,56 @@ OAuthDetailsRequestVCI: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "$1STLANG$", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_2ndLang_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "$2NDLANG$", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index 2f38f8f22ea..dd5d549aac4 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -779,4 +779,108 @@ OAuthDetailsRequestVCINegTC: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Missing_ClaimsLocales_Valid_Smoke: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "$REMOVE$", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Empty_ClaimsLocales_Valid_Smoke: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_SpaceVal_ClaimsLocales_Valid_Smoke: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": " ", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_Invalid_ClaimsLocales_Valid_Smoke: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "sdfsd", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' \ No newline at end of file From 975c61d586674b119c5e5d852c432ea4755dd7b4 Mon Sep 17 00:00:00 2001 From: Pankaj Godiyal Date: Thu, 21 Sep 2023 21:17:39 +0530 Subject: [PATCH 167/204] Added conditional loggings --- .../apirig/admin/fw/util/AdminTestUtil.java | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 63c9d8b49ba..dee21eab9a3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4709,7 +4709,6 @@ public static int getOtpExpTimeFromActuator() { String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new org.json.JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4722,6 +4721,8 @@ public static int getOtpExpTimeFromActuator() { org.json.JSONObject otpExpiryTime = (org.json.JSONObject) eachJson .getJSONObject(GlobalConstants.PROPERTIES).get("mosip.kernel.otp.expiry-time"); otpExpTime = otpExpiryTime.getString(GlobalConstants.VALUE); + if (ConfigManager.IsDebugEnabled()) + logger.info("Actuator: " +url +" otpExpTime: "+otpExpTime); break; } } @@ -4741,7 +4742,6 @@ public static String getValueFromActuator(String section, String key) { String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4751,6 +4751,8 @@ public static String getValueFromActuator(String section, String key) { if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); + if (ConfigManager.IsDebugEnabled()) + logger.info("Actuator: " +url + " key: "+key+" value: "+value); break; } } @@ -4772,7 +4774,6 @@ public static String getValueFromEsignetActuator(String section, String key) { String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4782,6 +4783,8 @@ public static String getValueFromEsignetActuator(String section, String key) { if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); + if (ConfigManager.IsDebugEnabled()) + logger.info("Actuator: " +url + " key: "+key+" value: "+value); break; } } @@ -4799,11 +4802,10 @@ public static String getValueFromAuthActuator(String section, String key) { Response response = null; JSONObject responseJson = null; JSONArray responseArray = null; - String url = ConfigManager.getEsignetBaseUrl() + propsKernel.getProperty("actuatorIDAEndpoint"); + String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4813,6 +4815,8 @@ public static String getValueFromAuthActuator(String section, String key) { if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); + if (ConfigManager.IsDebugEnabled()) + logger.info("Actuator: " +url + " key: "+key+" value: "+value); break; } } From 3e4f3029c11f0e791458db22e8df5bfe0b2a0698 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 22 Sep 2023 13:17:15 +0530 Subject: [PATCH 168/204] MOSIP-29547 --- .../apirig/admin/fw/util/AdminTestUtil.java | 108 ++++++++++-------- .../testrig/apirig/service/BaseTestCase.java | 22 ++-- 2 files changed, 71 insertions(+), 59 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index e5d2797245b..544a45eee29 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4777,22 +4777,23 @@ public static int getOtpExpTimeFromActuator() { } return Integer.parseInt(otpExpTime); } + + public static JSONArray residentActuatorResponseArray = null; public static String getValueFromActuator(String section, String key) { - - Response response = null; - JSONObject responseJson = null; - JSONArray responseArray = null; String url = ApplnURI + propsKernel.getProperty("actuatorEndpoint"); String value = null; try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - - responseJson = new JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + if (residentActuatorResponseArray == null) { + Response response = null; + JSONObject responseJson = null; + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - for (int i = 0, size = responseArray.length(); i < size; i++) { - JSONObject eachJson = responseArray.getJSONObject(i); + responseJson = new JSONObject(response.getBody().asString()); + residentActuatorResponseArray = responseJson.getJSONArray("propertySources"); + } + for (int i = 0, size = residentActuatorResponseArray.length(); i < size; i++) { + JSONObject eachJson = residentActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); @@ -4809,22 +4810,23 @@ public static String getValueFromActuator(String section, String key) { } } + + public static JSONArray esignetActuatorResponseArray = null; public static String getValueFromEsignetActuator(String section, String key) { - - Response response = null; - JSONObject responseJson = null; - JSONArray responseArray = null; - String url = ConfigManager.getEsignetBaseUrl() + propsKernel.getProperty("actuatorEsignetEndpoint"); String value = null; + String url = ConfigManager.getEsignetBaseUrl() + propsKernel.getProperty("actuatorEsignetEndpoint"); try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - - responseJson = new JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + if (esignetActuatorResponseArray == null) { + Response response = null; + JSONObject responseJson = null; + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + responseJson = new JSONObject(response.getBody().asString()); + esignetActuatorResponseArray = responseJson.getJSONArray("propertySources"); + } - for (int i = 0, size = responseArray.length(); i < size; i++) { - JSONObject eachJson = responseArray.getJSONObject(i); + for (int i = 0, size = esignetActuatorResponseArray.length(); i < size; i++) { + JSONObject eachJson = esignetActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); @@ -4841,22 +4843,24 @@ public static String getValueFromEsignetActuator(String section, String key) { } } + + public static JSONArray authActuatorResponseArray = null; public static String getValueFromAuthActuator(String section, String key) { - - Response response = null; - JSONObject responseJson = null; - JSONArray responseArray = null; String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); String value = null; try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + if (authActuatorResponseArray == null) { + Response response = null; + JSONObject responseJson = null; + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - responseJson = new JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + responseJson = new JSONObject(response.getBody().asString()); + authActuatorResponseArray = responseJson.getJSONArray("propertySources"); + } - for (int i = 0, size = responseArray.length(); i < size; i++) { - JSONObject eachJson = responseArray.getJSONObject(i); + for (int i = 0, size = authActuatorResponseArray.length(); i < size; i++) { + JSONObject eachJson = authActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); @@ -4873,23 +4877,26 @@ public static String getValueFromAuthActuator(String section, String key) { } } + + public static JSONArray configActuatorResponseArray = null; public static String getValueFromConfigActuator() { - Response response = null; - JSONObject responseJson = null; - JSONArray responseArray = null; String url = ApplnURI + propsKernel.getProperty("actuatorEndpoint"); String claims = null; try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); + if (configActuatorResponseArray == null) { + Response response = null; + JSONObject responseJson = null; + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); - responseJson = new JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + responseJson = new JSONObject(response.getBody().asString()); + configActuatorResponseArray = responseJson.getJSONArray("propertySources"); + } - for (int i = 0, size = responseArray.length(); i < size; i++) { - JSONObject eachJson = responseArray.getJSONObject(i); + for (int i = 0, size = configActuatorResponseArray.length(); i < size; i++) { + JSONObject eachJson = configActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(GlobalConstants.RESIDENT_DEFAULT_PROPERTIES)) { String claimVal = eachJson.getJSONObject(GlobalConstants.PROPERTIES) .getJSONObject("mosip.iam.module.login_flow.claims").getString(GlobalConstants.VALUE); @@ -4906,23 +4913,25 @@ public static String getValueFromConfigActuator() { } } + + public static JSONArray regProcActuatorResponseArray = null; public static String getRegprocWaitFromActuator() { - - Response response = null; - JSONObject responseJson = null; - JSONArray responseArray = null; String url = ApplnURI + propsKernel.getProperty("actuatorRegprocEndpoint"); String waitInterval = null; try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); + if (regProcActuatorResponseArray == null) { + Response response = null; + JSONObject responseJson = null; + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); - responseJson = new JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + responseJson = new JSONObject(response.getBody().asString()); + regProcActuatorResponseArray = responseJson.getJSONArray("propertySources"); + } - for (int i = 0, size = responseArray.length(); i < size; i++) { - JSONObject eachJson = responseArray.getJSONObject(i); + for (int i = 0, size = regProcActuatorResponseArray.length(); i < size; i++) { + JSONObject eachJson = regProcActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains("registration-processor-default.properties")) { waitInterval = eachJson.getJSONObject(GlobalConstants.PROPERTIES) .getJSONObject("registration.processor.reprocess.minutes").get(GlobalConstants.VALUE) @@ -4936,7 +4945,6 @@ public static String getRegprocWaitFromActuator() { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); return waitInterval; } - } public static String isTestCaseValidForExecution(TestCaseDTO testCaseDTO) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index be5e6c16379..e476d95f90a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -511,22 +511,26 @@ public static void userCenterMappingStatus() { logger.info(response); } + public static JSONArray idaActuatorResponseArray = null; + public static String getValueFromActuators(String endPoint, String section, String key) { - Response response = null; - org.json.JSONObject responseJson = null; - JSONArray responseArray = null; String url = ApplnURI + endPoint; String value = null; try { - response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); + if (idaActuatorResponseArray == null) { + Response response = null; + org.json.JSONObject responseJson = null; + response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); - responseJson = new org.json.JSONObject(response.getBody().asString()); - responseArray = responseJson.getJSONArray("propertySources"); + responseJson = new org.json.JSONObject(response.getBody().asString()); + idaActuatorResponseArray = responseJson.getJSONArray("propertySources"); + } - for (int i = 0, size = responseArray.length(); i < size; i++) { - org.json.JSONObject eachJson = responseArray.getJSONObject(i); + + for (int i = 0, size = idaActuatorResponseArray.length(); i < size; i++) { + org.json.JSONObject eachJson = idaActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); From 6e6968f6f61417725fbb3d668db85eef683f7095 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 22 Sep 2023 13:27:32 +0530 Subject: [PATCH 169/204] MOSIP-29513 --- .../esignet/AddIdentity/AddIdentity.yml | 54 +++++++++++++++ .../esignet/GenerateVID/createGenerateVID.yml | 68 +++++++++++++++++++ 2 files changed, 122 insertions(+) diff --git a/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml index eb31e4d76a3..448f63eded4 100644 --- a/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/esignet/AddIdentity/AddIdentity.yml @@ -456,4 +456,58 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + + ESignet_AddIdentity_Valid_Params_VCI_Vid_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: esignet/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: esignet/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "ESignet_AddIdentity_Valid_Params_VCI_Vid_smoke_Pos@mosip.net", + "phone": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + + ESignet_AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: esignet/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: esignet/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "ESignet_AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos@mosip.net", + "phone": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml index c8a0e18783f..07c2d8abfb3 100644 --- a/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml @@ -439,4 +439,72 @@ GenerateVID: "sendOtpResTemplate":"esignet/SendOTPRes/createSendOTPResult", "maskedEmail": "$IGNORE$" } +}' + + ESignetRes_Generate_Perpetual_VID_VCI_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + inputTemplate: esignet/GenerateVID/createGenerateVID + outputTemplate: esignet/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "esignet/SendOTPRes/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "vid": "$IGNORE$", + "message": "Notification has been sent to the provided contact detail(s)", + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOTPRes/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignetRes_Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + inputTemplate: esignet/GenerateVID/createGenerateVID + outputTemplate: esignet/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "esignet/SendOTPRes/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "vid": "$IGNORE$", + "message": "Notification has been sent to the provided contact detail(s)", + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOTPRes/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file From 6a45a88e8abe36e32c94e32a1e51f36d0e4f28a8 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 22 Sep 2023 19:56:26 +0530 Subject: [PATCH 170/204] MOSIP-29513 --- .../apirig/admin/fw/util/AdminTestUtil.java | 25 ++++++++--- .../AuthenticateUserVCI.yml | 33 +++++++++++++++ .../AuthorizationCodeVCI.yml | 16 ++++++++ .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 20 +++++++++ .../VCI/GetCredential/GetCredential.yml | 41 +++++++++++++++++++ .../OAuthDetailsRequestVCI.yml | 26 ++++++++++++ .../VCINegTC/GetCredential/GetCredential.yml | 41 ++++++++++++++----- 7 files changed, 186 insertions(+), 16 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 544a45eee29..d7be2c27aaa 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3231,7 +3231,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { accessToken = request.getString("idpAccessToken"); } jsonString = request.toString(); - jsonString = replaceKeywordWithValue(jsonString, "$PROOFJWT$", signJWK(clientId, accessToken, oidcJWKKey1)); + jsonString = replaceKeywordWithValue(jsonString, "$PROOFJWT$", signJWK(clientId, accessToken, oidcJWKKey1, testCaseName)); } if (jsonString.contains(GlobalConstants.REMOVE)) @@ -3240,12 +3240,15 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { return jsonString; } - public static String signJWK(String clientId, String accessToken, RSAKey jwkKey) { + public static String signJWK(String clientId, String accessToken, RSAKey jwkKey, String testCaseName) { String tempUrl = getValueFromActuator(GlobalConstants.RESIDENT_DEFAULT_PROPERTIES, "mosip.iam.base.url"); int idTokenExpirySecs = Integer.parseInt(getValueFromEsignetActuator(GlobalConstants.ESIGNET_DEFAULT_PROPERTIES, GlobalConstants.MOSIP_ESIGNET_ID_TOKEN_EXPIRE_SECONDS)); JWSSigner signer; String proofJWT = ""; + String nonce = "jwt_payload.c_nonce123"; + String typ = "openid4vci-proof+jwt"; + JWK jwkHeader = jwkKey.toPublicJWK(); try { signer = new RSASSASigner(jwkKey); @@ -3254,13 +3257,23 @@ public static String signJWK(String clientId, String accessToken, RSAKey jwkKey) String jwtPayloadBase64 = jwtParts[1]; byte[] jwtPayloadBytes = Base64.getDecoder().decode(jwtPayloadBase64); String jwtPayload = new String(jwtPayloadBytes, StandardCharsets.UTF_8); + JWTClaimsSet claimsSet = null; + + if (testCaseName.contains("_Invalid_C_nonce_")) { + claimsSet = new JWTClaimsSet.Builder().audience(tempUrl) + .claim("nonce", nonce) + .issuer(clientId).issueTime(new Date()) + .expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); + } else { - JWTClaimsSet claimsSet = new JWTClaimsSet.Builder().audience(tempUrl) - .claim("nonce", new ObjectMapper().readTree(jwtPayload).get("c_nonce").asText()).issuer(clientId) - .issueTime(new Date()).expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); + claimsSet = new JWTClaimsSet.Builder().audience(tempUrl) + .claim("nonce", new ObjectMapper().readTree(jwtPayload).get("c_nonce").asText()) + .issuer(clientId).issueTime(new Date()) + .expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); + } SignedJWT signedJWT = new SignedJWT(new JWSHeader.Builder(JWSAlgorithm.RS256) - .type(new JOSEObjectType("openid4vci-proof+jwt")).jwk(jwkKey.toPublicJWK()).build(), claimsSet); + .type(new JOSEObjectType(typ)).jwk(jwkHeader).build(), claimsSet); signedJWT.sign(signer); proofJWT = signedJWT.serialize(); diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index eb2d981ed49..d12428f507e 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -32,6 +32,39 @@ AuthenticateUserVCI: } }' + ESignet_AuthenticateUserVCI_Vid_Otp_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + ESignet_AuthenticateUserVCI_uin_Otp_1stLang_Valid_Smoke: endPoint: /v1/esignet/authorization/authenticate role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 33f1184f249..26d7abc3479 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -15,6 +15,22 @@ AuthorizationCodeVCI: output: '{ }' + ESignet_AuthorizationCode_VCI_Vid_All_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + ESignet_AuthorizationCode_VCI_uin_All_1stLang_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index a80fc64300b..6f172d373f5 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -19,6 +19,26 @@ GenerateTokenVCI: "token_type": "Bearer" }' + ESignet_GenerateTokenVCI_Vid_Valid_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_Vid_All_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + ESignet_GenerateTokenVCI_uin_1stLang_Valid_Smoke_sid: endPoint: /v1/esignet/oauth/v2/token role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index be637698ad6..fac3004558e 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -57,4 +57,45 @@ GetCredential: "proof_jwt": "$PROOFJWT$" }' output: '{ +}' + + ESignet_GetCredential_uin_IdpAccessToken_2ndLang_Invalid_Token_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_2ndLang_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"vci_exchange_failed" +}' + + ESignet_GetCredential_Vid_IdpAccessToken_all_Valid_Smoke: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/VCI/GetCredential/GetCredentialResult + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_Vid_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index 4767e52a453..4b9af83b95b 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -23,6 +23,32 @@ OAuthDetailsRequestVCI: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' ESignet_OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid: diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml index 26b2ca61f43..856e6da21ee 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml @@ -342,7 +342,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}] @@ -361,7 +361,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -382,7 +382,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -403,7 +403,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -424,7 +424,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -445,7 +445,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -466,7 +466,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -487,7 +487,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -508,7 +508,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -529,7 +529,7 @@ GetCredentialNegTC: outputTemplate: esignet/error2 input: '{ "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_uin_Valid_Smoke_sid_access_token$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", "format": "ldp_vc", "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], "@context": [{context: "$VCICONTEXTURL$"}], @@ -538,4 +538,25 @@ GetCredentialNegTC: }' output: '{ "error": "invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_C_nonce_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" }' \ No newline at end of file From 69359ba803cc3b6104cebc95c6cdad4e8ab41985 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 25 Sep 2023 10:52:54 +0530 Subject: [PATCH 171/204] MOSIP-29559 --- .../apirig/admin/fw/util/AdminTestUtil.java | 57 ++++++++++ .../ida/certificate/PartnerRegistration.java | 60 +++++++++- .../apirig/testrunner/MosipTestRunner.java | 3 + .../testscripts/MultiFactorAuthNew.java | 107 +++++++++--------- 4 files changed, 173 insertions(+), 54 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 59748697297..7f53b326586 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -184,7 +184,9 @@ public static BioDataUtility getBioDataUtil() { protected static String preregHbsForUpdate = null; protected static String timeStamp = String.valueOf(Calendar.getInstance().getTimeInMillis()); protected static String policyGroup = "mosip auth policy group " + timeStamp; + protected static String policyGroup2 = "mosip auth policy group2 " + timeStamp; protected static String policyName = "mosip auth policy " + timeStamp; + protected static String policyName2 = "mosip auth policy2 " + timeStamp; protected static final String UPDATE_UIN_REQUEST = "config/Authorization/requestIdentity.json"; protected static final String AUTH_INTERNAL_REQUEST = "config/Authorization/internalAuthRequest.json"; protected static final String AUTH_POLICY_BODY = "config/AuthPolicy.json"; @@ -4649,6 +4651,61 @@ public static void createAndPublishPolicy() { MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); } + + + @SuppressWarnings("unchecked") + public static void createAndPublishPolicyForKyc() { + if (!BaseTestCase.isTargetEnvLTS()) { + // In case of 1.1.5 we don't have auto sync of certificates between Key manager + // cert store and IDA cert store + // So use the predefined certificate folder and partner key + return; + } + + String token = kernelAuthLib.getTokenByRole(GlobalConstants.PARTNER); + + String url2 = ApplnURI + properties.getProperty("policyGroupUrl"); + org.json.simple.JSONObject actualrequest = getRequestJson(POLICY_GROUP_REQUEST); + + org.json.simple.JSONObject modifiedReq = new org.json.simple.JSONObject(); + modifiedReq.put("desc", "desc mosip auth policy group"); + modifiedReq.put("name", policyGroup2); + + actualrequest.put(GlobalConstants.REQUEST, modifiedReq); + + Response response2 = RestClient.postRequestWithCookie(url2, actualrequest, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + String responseBody2 = response2.getBody().asString(); + String policygroupId2 = new org.json.JSONObject(responseBody2).getJSONObject(GlobalConstants.RESPONSE) + .getString("id"); + + String url = ApplnURI + properties.getProperty("authPolicyUrl"); + org.json.simple.JSONObject actualrequestBody = getRequestJson(AUTH_POLICY_BODY); + org.json.simple.JSONObject actualrequest2 = getRequestJson(AUTH_POLICY_REQUEST); + org.json.simple.JSONObject actualrequestAttr = getRequestJson(AUTH_POLICY_REQUEST_ATTR); + + actualrequest2.put("name", policyName2); + actualrequest2.put("policyGroupName", policyGroup2); + actualrequest2.put("policies", actualrequestAttr); + actualrequestBody.put(GlobalConstants.REQUEST, actualrequest2); + + Response response = RestClient.postRequestWithCookie(url, actualrequestBody, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + String responseBody = response.getBody().asString(); + String policyId2 = new org.json.JSONObject(responseBody).getJSONObject(GlobalConstants.RESPONSE).getString("id"); + + String url3 = ApplnURI + properties.getProperty("publishPolicyurl"); + + if (url3.contains("POLICYID")) { + url3 = url3.replace("POLICYID", policyId2); + url3 = url3.replace("POLICYGROUPID", policygroupId2); + + } + + Response response3 = RestClient.postRequestWithCookie(url3, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + + } public static String getJWKKey(File fileName) { String keyString = null; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java index e6c38575950..599c44ccee6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java @@ -20,6 +20,7 @@ public class PartnerRegistration extends AdminTestUtil { private static final Logger lOGGER = Logger.getLogger(PartnerRegistration.class); public static String partnerKeyUrl = null; + public static String ekycPartnerKeyUrl = null; static String localHostUrl = null; static String address = "Bangalore"; @@ -29,11 +30,16 @@ public class PartnerRegistration extends AdminTestUtil { static String emailId2 = "mosip_2" + timeStamp + "@gmail.com"; static String emailId3 = "mosip_3" + timeStamp + "@gmail.com"; public static String organizationName = "mosip_partnerorg" + timeStamp; + public static String ekycOrganizationName = "mosip_ekyc_partner" + timeStamp; public static String deviceOrganizationName = "mosip_deviceorg" + timeStamp; public static String ftmOrganizationName = "mosip_ftmorg" + timeStamp; public static String partnerId = organizationName; + public static String ekycPartnerId = ekycOrganizationName; public static String partnerType = "AUTH_PARTNER"; static String getPartnerType = "RELYING_PARTY"; + static String getEkycPartnerType = "EKYC"; + public static String apiKey = ""; + public static String mispLicKey =""; public static String policyGroup = AdminTestUtil.policyGroup; public static void setLogLevel() { @@ -51,13 +57,12 @@ public static String generateAndGetPartnerKeyUrl() { partnerId = getPartnerIdFromPartnerURL(partnerKeyUrl); return ConfigManager.getPartnerUrlSuffix(); } - String apiKey = ""; ftmGeneration(); deviceGeneration(); getAndUploadCertificates(); apiKey = KeyCloakUserAndAPIKeyGeneration.createKCUserAndGetAPIKey(); - String mispLicKey = MispPartnerAndLicenseKeyGeneration.getAndUploadCertificatesAndGenerateMispLicKey(); + mispLicKey = MispPartnerAndLicenseKeyGeneration.getAndUploadCertificatesAndGenerateMispLicKey(); if (apiKey.isEmpty() || mispLicKey.isEmpty()) { lOGGER.error("Failed to generate API key and MISP Lic key"); @@ -69,6 +74,32 @@ public static String generateAndGetPartnerKeyUrl() { return partnerKeyUrl; } + + public static String generateAndGetEkycPartnerKeyUrl() { + if (!BaseTestCase.isTargetEnvLTS()) { + // In case of 1.1.5 we don't have auto sync of certificates between Key manager cert store and IDA cert store + // So use the predefined certificate folder and partner key + ekycPartnerKeyUrl = ConfigManager.getPartnerUrlSuffix(); + ekycPartnerId = getPartnerIdFromPartnerURL(ekycPartnerKeyUrl); + return ConfigManager.getPartnerUrlSuffix(); + } + + ftmGeneration(); + deviceGeneration(); + + + getAndUploadEkycCertificates(); + + if (apiKey.isEmpty() || mispLicKey.isEmpty()) { + lOGGER.error("Failed to generate API key and MISP Lic key"); + return ""; + } + ekycPartnerKeyUrl = mispLicKey + "/" + ekycPartnerId + "/" + apiKey; + + lOGGER.info("ekycPartnerKeyUrl = " + ekycPartnerKeyUrl); + + return ekycPartnerKeyUrl; + } public static void getAndUploadCertificates() { if (localHostUrl == null) { @@ -94,6 +125,31 @@ public static void getAndUploadCertificates() { uploadSignedCertificate(certValueSigned, getPartnerType, partnerId, true); } + + public static void getAndUploadEkycCertificates() { + if (localHostUrl == null) { + localHostUrl = getLocalHostUrl(); + } + + partnerGeneration(); + JSONObject certificateValue = getCertificates(ekycPartnerId, getEkycPartnerType); + String caCertValue = certificateValue.getString("caCertificate"); + lOGGER.info(caCertValue); + String interCertValue = certificateValue.getString("interCertificate"); + lOGGER.info(interCertValue); + String partnerCertValue = certificateValue.getString("partnerCertificate"); + lOGGER.info(partnerCertValue); + + uploadCACertificate(caCertValue, "Auth"); + uploadIntermediateCertificate(interCertValue, "Auth"); + + JSONObject signedcertificateValue = uploadPartnerCertificate(partnerCertValue, "Auth", ekycPartnerId); + + String certValueSigned = signedcertificateValue.getString("signedCertificateData"); + lOGGER.info(certValueSigned); + uploadSignedCertificate(certValueSigned, getEkycPartnerType, ekycPartnerId, true); + + } private static String getLocalHostUrl() { return ConfigManager.getAuthDemoServiceUrl() + "/"; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 9d62b4402c5..ae778340234 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -89,13 +89,16 @@ public static void main(String[] arg) { AdminTestUtil.getLocationData(); String partnerKeyURL = ""; + //String ekycPartnerKeyURL = ""; if (BaseTestCase.listOfModules.contains("auth") || BaseTestCase.listOfModules.contains(GlobalConstants.ESIGNET)) { PartnerRegistration.deleteCertificates(); CertificateGenerationUtil.getThumbprints(); AdminTestUtil.createAndPublishPolicy(); + //AdminTestUtil.createAndPublishPolicyForKyc(); partnerKeyURL = PartnerRegistration.generateAndGetPartnerKeyUrl(); + //ekycPartnerKeyURL = PartnerRegistration.generateAndGetEkycPartnerKeyUrl(); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java index 2f247f3bfda..37b56cf6120 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java @@ -67,7 +67,6 @@ public Object[] getTestCaseList(ITestContext context) { logger.info("Started executing yml: " + ymlFile); return getYmlTestData(ymlFile); } - /** * Test method for OTP Generation execution @@ -81,18 +80,18 @@ public Object[] getTestCaseList(ITestContext context) { @Test(dataProvider = "testcaselist") public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, AdminTestException { testCaseName = testCaseDTO.getTestCaseName(); - + if (HealthChecker.signalTerminateExecution) { throw new SkipException("Target env health check failed " + HealthChecker.healthCheckFailureMapS); } - + if (testCaseDTO.getTestCaseName().contains("uin") || testCaseDTO.getTestCaseName().contains("UIN")) { if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("UIN") && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("uin")) { throw new SkipException("Idtype UIN is not supported. Hence skipping the testcase"); } } - + if (testCaseDTO.getTestCaseName().contains("vid") || testCaseDTO.getTestCaseName().contains("VID")) { if (!BaseTestCase.getSupportedIdTypesValueFromActuator().contains("VID") && !BaseTestCase.getSupportedIdTypesValueFromActuator().contains("vid")) { @@ -118,53 +117,58 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad requestBody.put("partnerName", PartnerRegistration.partnerId); requestBody.put("moduleName", BaseTestCase.certsForModule); requestBody.put(GlobalConstants.TRANSACTIONID, "$TRANSACTIONID$"); - + String token = kernelAuthLib.getTokenByRole(GlobalConstants.RESIDENT); - - Response sendOtpReqResp = postWithOnlyQueryParamAndCookie(url + "/v1/identity/createOtpReqest", requestBody.toString(), GlobalConstants.AUTHORIZATION, GlobalConstants.RESIDENT, testCaseName); - - - - String otpInput = sendOtpReqResp.getBody().asString(); - logger.info(otpInput); - String signature = sendOtpReqResp.getHeader("signature"); - Object sendOtpBody = otpInput; - logger.info(sendOtpBody); - - HashMap headers = new HashMap<>(); - headers.put(AUTHORIZATHION_HEADERNAME, token); - headers.put(SIGNATURE_HEADERNAME, signature); - - Response otpRespon = null; - - otpRespon = postRequestWithAuthHeaderAndSignatureForOtp(ApplnURI + "/idauthentication/v1/otp/"+ PartnerRegistration.partnerKeyUrl, sendOtpBody.toString(), GlobalConstants.AUTHORIZATION, token, headers, testCaseName); - - JSONObject res = new JSONObject(testCaseDTO.getOutput()); - String sendOtpResp = null; - String sendOtpResTemplate = null; - if (res.has(GlobalConstants.SENDOTPRESP)) { - sendOtpResp = res.get(GlobalConstants.SENDOTPRESP).toString(); - res.remove(GlobalConstants.SENDOTPRESP); - } - JSONObject sendOtpRespJson = new JSONObject(sendOtpResp); - sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); - sendOtpRespJson.remove("sendOtpResTemplate"); - Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( - otpRespon.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); - Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); - - if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) - throw new AdminTestException("Failed at Send OTP output validation"); - - if(testCaseDTO.getTestCaseName().contains("expiredOTP")) { - try { - Thread.sleep(Long.parseLong(properties.getProperty("expireOtpTime"))); - } catch (NumberFormatException e) { - logger.error("Exception : " + e.getMessage()); - } catch (InterruptedException e) { - logger.error("Exception : " + e.getMessage()); + if (input.has("otp") && !input.get("otp").toString().equalsIgnoreCase("otp")) { + + Response sendOtpReqResp = postWithOnlyQueryParamAndCookie(url + "/v1/identity/createOtpReqest", + requestBody.toString(), GlobalConstants.AUTHORIZATION, GlobalConstants.RESIDENT, testCaseName); + + String otpInput = sendOtpReqResp.getBody().asString(); + logger.info(otpInput); + String signature = sendOtpReqResp.getHeader("signature"); + Object sendOtpBody = otpInput; + logger.info(sendOtpBody); + + HashMap headers = new HashMap<>(); + headers.put(AUTHORIZATHION_HEADERNAME, token); + headers.put(SIGNATURE_HEADERNAME, signature); + + Response otpRespon = null; + + otpRespon = postRequestWithAuthHeaderAndSignatureForOtp( + ApplnURI + "/idauthentication/v1/otp/" + PartnerRegistration.partnerKeyUrl, sendOtpBody.toString(), + GlobalConstants.AUTHORIZATION, token, headers, testCaseName); + + JSONObject res = new JSONObject(testCaseDTO.getOutput()); + String sendOtpResp = null; + String sendOtpResTemplate = null; + if (res.has(GlobalConstants.SENDOTPRESP)) { + sendOtpResp = res.get(GlobalConstants.SENDOTPRESP).toString(); + res.remove(GlobalConstants.SENDOTPRESP); + } + JSONObject sendOtpRespJson = new JSONObject(sendOtpResp); + sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); + sendOtpRespJson.remove("sendOtpResTemplate"); + Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( + otpRespon.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), + testCaseDTO.isCheckErrorsOnlyInResponse()); + Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); + + if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) + throw new AdminTestException("Failed at Send OTP output validation"); + + if (testCaseDTO.getTestCaseName().contains("expiredOTP")) { + try { + Thread.sleep(Long.parseLong(properties.getProperty("expireOtpTime"))); + } catch (NumberFormatException e) { + logger.error("Exception : " + e.getMessage()); + } catch (InterruptedException e) { + logger.error("Exception : " + e.getMessage()); + } } + } String endPoint = testCaseDTO.getEndPoint(); @@ -180,10 +184,10 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad String inputStr = buildIdentityRequest(input.toString()); String authRequest = getJsonFromTemplate(inputStr, testCaseDTO.getInputTemplate()); - logger.info("******Post request Json to EndPointUrl: " + url + endPoint + " *******"); - + logger.info("******Post request Json to EndPointUrl: " + url + endPoint + " *******"); + response = postWithBodyAndCookie(url + endPoint, authRequest, COOKIENAME, testCaseDTO.getRole(), testCaseName); - + logger.info(response); String ActualOPJson = getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()); @@ -212,7 +216,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); - } /** From 8e07d3e75156eb7dbf44301a8c5e1814d7d89756 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Mon, 25 Sep 2023 11:46:11 +0530 Subject: [PATCH 172/204] Mandatory lang not present handke --- .../testrig/apirig/service/BaseTestCase.java | 21 ++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index be5e6c16379..ac43d6109a4 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -547,23 +547,30 @@ public static List getLanguageList() { return languageList; } String section = ""; - + String optionalLanguages=null; + String mandatoryLanguages=null; if (isTargetEnvLTS()) section = "/mosip/mosip-config/application-default.properties"; else section = "/mosip/mosip-config/sandbox/admin-mz.properties"; - - String mandatoryLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), - section, "mosip.mandatory-languages"); - String optionalLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), + try { + + optionalLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), section, "mosip.optional-languages"); - + logger.info("optionalLanguages from env:" + optionalLanguages); + mandatoryLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), + section, "mosip.mandatoryLanguages from env:" + mandatoryLanguages); + } + catch(Exception e) + { + e.printStackTrace(); + } if (mandatoryLanguages != null && !mandatoryLanguages.isBlank()) languageList.addAll(Arrays.asList(mandatoryLanguages.split(","))); if (optionalLanguages != null && !optionalLanguages.isBlank()) languageList.addAll(Arrays.asList(optionalLanguages.split(","))); - + logger.info("languageList from env:" + languageList); return languageList; } From be33defec8f7d019977830640d04890c58e1598d Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Mon, 25 Sep 2023 15:20:55 +0530 Subject: [PATCH 173/204] MOSIP-28071 --- .../apirig/admin/fw/util/AdminTestUtil.java | 26 +++++-- .../apirig/testrunner/MosipTestRunner.java | 5 +- .../testrig/apirig/testscripts/KycAuth.java | 2 +- ...ostWithBodyAndQueryParamsForAutoGenId.java | 12 +++- .../esignet/KycBioAuth/KycBioAuth.yml | 72 +++++++++++++------ .../PmsIntegration/UploadCert/UploadCert.yml | 2 +- .../testNgXmlFiles/esignetSuite.xml | 12 +++- 7 files changed, 95 insertions(+), 36 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 14acbba3836..88e7fce1807 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -143,7 +143,7 @@ public class AdminTestUtil extends BaseTestCase { + "config/healthCheckEndpoint.properties"; private static String serverComponentsCommitDetails; - String token = null; + String token = null; String idToken = null; String adminAutoGeneratedIdPropFileName = properties.getProperty("adminAutoGeneratedIdPropFileName"); String masterDataAutoGeneratedIdPropFileName = properties.getProperty("masterDataAutoGeneratedIdPropFileName"); @@ -2827,9 +2827,9 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$LOCATIONCODE$", locationCode); // Need to handle int replacement - // if (jsonString.contains("$HIERARCHYLEVEL$")) - // jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYLEVEL$", - // hierarchyLevel); + if (jsonString.contains("$HIERARCHYLEVEL$")) + jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYLEVEL$", + String.valueOf(hierarchyLevel)); if (jsonString.contains("$HIERARCHYNAME$")) jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYNAME$", hierarchyName); @@ -3455,16 +3455,30 @@ private String replaceIdWithAutogeneratedId(String jsonString, String idKey, Str else time += " AM"; jsonString = replaceKeywordWithValue(jsonString, keyToReplace, time); - } else - jsonString = replaceKeywordWithValue(jsonString, keyToReplace, props.getProperty(keyForIdProperty)); + } else { + if(keyForIdProperty.equals("UploadPartnerCert_Misp_Valid_Smoke_sid_signedCertificateData")) { + String certData = props.getProperty(keyForIdProperty); + if (System.getProperty(GlobalConstants.OS_NAME).toLowerCase().contains(GlobalConstants.WINDOWS)) { + certData = certData.replaceAll("\n", "\\\\n"); + } else { + certData = certData.replaceAll("\n", "\\\\n"); + + } + jsonString = replaceKeywordWithValue(jsonString, keyToReplace, certData); + } + else + jsonString = replaceKeywordWithValue(jsonString, keyToReplace, props.getProperty(keyForIdProperty)); + } if (jsonString.contains("\u200B")) { jsonString = jsonString.replaceAll("\u200B", ""); } if (jsonString.contains("\\p{Cf}")) { jsonString = jsonString.replaceAll("\\p{Cf}", ""); } + jsonString = replaceIdWithAutogeneratedId(jsonString, idKey, autoGenIdFileName); + if (jsonString.contains("\u200B")) { jsonString = jsonString.replaceAll("\u200B", ""); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 9d62b4402c5..a95f4927792 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -100,11 +100,10 @@ public static void main(String[] arg) { } if (BaseTestCase.listOfModules.contains(GlobalConstants.MASTERDATA)) { - - AdminTestUtil.getLocationLevelData(); - AdminTestUtil.getLocationData(); BaseTestCase.mapUserToZone(); BaseTestCase.mapZone(); + AdminTestUtil.getLocationLevelData(); + AdminTestUtil.getLocationData(); AdminTestUtil.getZoneName(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java index 450782e2509..1a4304726f7 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java @@ -121,7 +121,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad HashMap headers = new HashMap<>(); headers.put(SIGNATURE_HEADERNAME, signature); String token = kernelAuthLib.getTokenByRole(testCaseDTO.getRole()); - + headers.put(COOKIENAME, token); logger.info("******Post request Json to EndPointUrl: " + ApplnURI + testCaseDTO.getEndPoint() + " *******"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java index 3d13d5114ff..5fe4c9e5035 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java @@ -1,6 +1,7 @@ package io.mosip.testrig.apirig.testscripts; import java.lang.reflect.Field; +import java.util.HashMap; import java.util.List; import java.util.Map; @@ -81,9 +82,18 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad logger.info("Not Getting"+GlobalConstants.POST_REQ_URL + testCaseDTO.getTestCaseName() + " *******"); } + Map> ouputValid = null; + if(testCaseName.contains("_StatusCode")) { + + OutputValidationDto customResponse = customStatusCodeResponse(String.valueOf(response.getStatusCode()), testCaseDTO.getOutput()); + + ouputValid = new HashMap<>(); + ouputValid.put("expected vs actual", List.of(customResponse)); + }else { - Map> ouputValid = OutputValidationUtil + ouputValid = OutputValidationUtil .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); + } Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml index 1f9c6296e51..5c3d73368a0 100644 --- a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml +++ b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml @@ -5,7 +5,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/KycBioAuth/KycBioAuthResultKycStatus input: '{ "bioSubType": "", "bioType": "FACE", @@ -27,13 +27,14 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": true + "kycStatus": true }' Esignet_KycBioAuth_vid_all_Valid_Smoke: endPoint: /v1/identity/createAuthRequest?id=$ID:Generate_Perpetual_VID_Kyc_Valid_Smoke_sid_vid$&idType=VID&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ role: resident restMethod: post + checkErrorsOnlyInResponse: true validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth outputTemplate: esignet/KycBioAuth/KycBioAuthResult @@ -58,7 +59,8 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": true + "authStatus": "$IGNORE$", + "kycStatus": true }' Esignet_KycBioAuth_uin_Invalid_Biovalue_Neg: @@ -67,7 +69,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/error input: '{ "bioSubType": "", "bioType": "FACE", @@ -89,7 +91,11 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": false + "errors": [ + { + "errorCode": "IDA-BIA-001" + } + ] }' Esignet_KycBioAuth_vid_Invalid_Biovalue_Neg: @@ -98,7 +104,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/error input: '{ "bioSubType": "", "bioType": "FACE", @@ -120,7 +126,11 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": false + "errors": [ + { + "errorCode": "IDA-BIA-001" + } + ] }' Esignet_KycBioAuth_uin_RingFinger_all_Valid_Smoke: @@ -129,7 +139,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/KycBioAuth/KycBioAuthResultKycStatus input: '{ "bioSubType": "Left RingFinger", "bioType": "Finger", @@ -151,7 +161,7 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": true + "kycStatus": true }' Esignet_KycBioAuth_vid_RingFinger_all_Valid_Smoke: @@ -160,7 +170,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/KycBioAuth/KycBioAuthResultKycStatus input: '{ "bioSubType": "Left RingFinger", "bioType": "Finger", @@ -182,7 +192,7 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": true + "kycStatus": true }' Esignet_KycBioAuth_uin_RingFinger_Invalid_Biovalue_Neg: @@ -191,7 +201,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/error input: '{ "bioSubType": "Left RingFinger", "bioType": "Finger", @@ -213,7 +223,11 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": false + "errors": [ + { + "errorCode": "IDA-BIA-001" + } + ] }' Esignet_KycBioAuth_vid_RingFinger_Invalid_Biovalue_Neg: @@ -222,7 +236,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/error input: '{ "bioSubType": "Left RingFinger", "bioType": "Finger", @@ -244,7 +258,11 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": false + "errors": [ + { + "errorCode": "IDA-BIA-001" + } + ] }' Esignet_KycBioAuth_uin_LeftIris_all_Valid_Smoke: @@ -253,7 +271,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/KycBioAuth/KycBioAuthResultKycStatus input: '{ "bioSubType": "Left", "bioType": "Iris", @@ -275,7 +293,7 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": true + "kycStatus": true }' Esignet_KycBioAuth_vid_LeftIris_all_Valid_Smoke: @@ -284,7 +302,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/KycBioAuth/KycBioAuthResultKycStatus input: '{ "bioSubType": "Left", "bioType": "Iris", @@ -306,7 +324,7 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": true + "kycStatus": true }' Esignet_KycBioAuth_uin_LeftIris_Invalid_Biovalue_Neg: @@ -315,7 +333,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/error input: '{ "bioSubType": "Left", "bioType": "Iris", @@ -337,7 +355,11 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": false + "errors": [ + { + "errorCode": "IDA-BIA-001" + } + ] }' Esignet_KycBioAuth_vid_LeftIris_Invalid_Biovalue_Neg: @@ -346,7 +368,7 @@ KycBioAuth: restMethod: post validityCheckRequired: true inputTemplate: esignet/KycBioAuth/KycBioAuth - outputTemplate: esignet/KycBioAuth/KycBioAuthResult + outputTemplate: esignet/error input: '{ "bioSubType": "Left", "bioType": "Iris", @@ -368,5 +390,9 @@ KycBioAuth: "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" }' output: '{ - "authStatus": false + "errors": [ + { + "errorCode": "IDA-BIA-001" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml index 2e3646aefde..ff3ddca3579 100644 --- a/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UploadCert/UploadCert.yml @@ -15,7 +15,7 @@ uploadPartnerCert: "errors": "$IGNORE$" }' - Esignet_UploadPartnerCert_Misp_Valid_Smoke: + Esignet_UploadPartnerCert_Misp_Valid_Smoke_sid: endPoint: /v1/partnermanager/partners/certificate/upload role: partner checkErrorsOnlyInResponse: true diff --git a/automationtests/testNgXmlFiles/esignetSuite.xml b/automationtests/testNgXmlFiles/esignetSuite.xml index 52d7f98a630..7d938151079 100644 --- a/automationtests/testNgXmlFiles/esignetSuite.xml +++ b/automationtests/testNgXmlFiles/esignetSuite.xml @@ -65,8 +65,18 @@ + - + + + + + + + + + From 35a4061c9b80cd5ff3a2107527d2a3d89e6aea00 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Mon, 25 Sep 2023 15:22:46 +0530 Subject: [PATCH 174/204] Mandatory lang not present handke --- .../io/mosip/testrig/apirig/service/BaseTestCase.java | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index ac43d6109a4..b882a153e91 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -523,8 +523,11 @@ public static String getValueFromActuators(String endPoint, String section, Stri GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new org.json.JSONObject(response.getBody().asString()); + logger.info("responseJson:" +responseJson); responseArray = responseJson.getJSONArray("propertySources"); - + logger.info("responseArray:" +responseArray); + logger.info("responseArray.length()" + responseArray.length()); + logger.info("endPoint="+endPoint +" section= "+section+" key= "+key); for (int i = 0, size = responseArray.length(); i < size; i++) { org.json.JSONObject eachJson = responseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(section)) { @@ -558,9 +561,11 @@ public static List getLanguageList() { optionalLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), section, "mosip.optional-languages"); logger.info("optionalLanguages from env:" + optionalLanguages); - mandatoryLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), - section, "mosip.mandatoryLanguages from env:" + mandatoryLanguages); + mandatoryLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), + section, "mosip.mandatory-languages"); + logger.info("mandatoryLanguages from env:" + mandatoryLanguages); } + catch(Exception e) { e.printStackTrace(); From 14192bd6c37eed45f2c1cfdd6b98a6b1e4024ea9 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Mon, 25 Sep 2023 15:24:40 +0530 Subject: [PATCH 175/204] Mandatory lang not present handke --- .../main/java/io/mosip/testrig/apirig/service/BaseTestCase.java | 1 + 1 file changed, 1 insertion(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index b882a153e91..a8a5c1d01b2 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -533,6 +533,7 @@ public static String getValueFromActuators(String endPoint, String section, Stri if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); + logger.info("value="+value); break; } } From 24055e9de9c021d79b0109c30b53f7874985cf57 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Mon, 25 Sep 2023 15:45:14 +0530 Subject: [PATCH 176/204] resolve conflict --- .../java/io/mosip/testrig/apirig/service/BaseTestCase.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 8c1724a22f1..9a7e5594544 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -527,13 +527,14 @@ public static String getValueFromActuators(String endPoint, String section, Stri responseJson = new org.json.JSONObject(response.getBody().asString()); idaActuatorResponseArray = responseJson.getJSONArray("propertySources"); } - + logger.info("idaActuatorResponseArray="+idaActuatorResponseArray); for (int i = 0, size = idaActuatorResponseArray.length(); i < size; i++) { org.json.JSONObject eachJson = idaActuatorResponseArray.getJSONObject(i); if (eachJson.get("name").toString().contains(section)) { value = eachJson.getJSONObject(GlobalConstants.PROPERTIES).getJSONObject(key) .get(GlobalConstants.VALUE).toString(); + logger.info("value="+value); break; } } From c73702b56ba73c7db1cb7d912cbfe5187671aca2 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 25 Sep 2023 19:54:18 +0530 Subject: [PATCH 177/204] MOSIP-29513 --- .../apirig/admin/fw/util/AdminTestUtil.java | 34 +++++----- .../AuthenticateUserVCI.yml | 33 ---------- .../AuthorizationCodeVCI.yml | 16 ----- .../VCI/GenerateTokenVCI/GenerateTokenVCI.yml | 20 ------ .../VCI/GetCredential/GetCredential.yml | 20 ------ .../OAuthDetailsRequestVCI.yml | 26 -------- .../VCINegTC/GetCredential/GetCredential.yml | 63 +++++++++++++++++++ .../AuthenticateUserVCI.hbs | 15 +++++ .../AuthenticateUserVCI.yml | 33 ++++++++++ .../AuthenticateUserVCIResult.hbs | 1 + .../AuthorizationCodeVCI.hbs | 19 ++++++ .../AuthorizationCodeVCI.yml | 16 +++++ .../AuthorizationCodeVCIResult.hbs | 1 + .../GenerateTokenVCI/GenerateTokenVCI.hbs | 9 +++ .../GenerateTokenVCI/GenerateTokenVCI.yml | 20 ++++++ .../GenerateTokenVCIResult.hbs | 3 + .../VCIVid/GetCredential/GetCredential.hbs | 23 +++++++ .../VCIVid/GetCredential/GetCredential.yml | 20 ++++++ .../GetCredentialEmptyCredDef.hbs | 10 +++ .../GetCredential/GetCredentialNoCredDef.hbs | 10 +++ .../GetCredential/GetCredentialNoProof.hbs | 19 ++++++ .../GetCredential/GetCredentialResult.hbs | 1 + .../OAuthDetailsRequestVCI.hbs | 17 +++++ .../OAuthDetailsRequestVCI.yml | 26 ++++++++ .../OAuthDetailsRequestVCIResult.hbs | 1 + 25 files changed, 327 insertions(+), 129 deletions(-) create mode 100644 automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialEmptyCredDef.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoCredDef.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoProof.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index d7be2c27aaa..d0da2c482cd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3246,9 +3246,9 @@ public static String signJWK(String clientId, String accessToken, RSAKey jwkKey, GlobalConstants.MOSIP_ESIGNET_ID_TOKEN_EXPIRE_SECONDS)); JWSSigner signer; String proofJWT = ""; - String nonce = "jwt_payload.c_nonce123"; String typ = "openid4vci-proof+jwt"; JWK jwkHeader = jwkKey.toPublicJWK(); + SignedJWT signedJWT = null; try { signer = new RSASSASigner(jwkKey); @@ -3258,22 +3258,28 @@ public static String signJWK(String clientId, String accessToken, RSAKey jwkKey, byte[] jwtPayloadBytes = Base64.getDecoder().decode(jwtPayloadBase64); String jwtPayload = new String(jwtPayloadBytes, StandardCharsets.UTF_8); JWTClaimsSet claimsSet = null; - - if (testCaseName.contains("_Invalid_C_nonce_")) { - claimsSet = new JWTClaimsSet.Builder().audience(tempUrl) - .claim("nonce", nonce) - .issuer(clientId).issueTime(new Date()) - .expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); - } else { + String nonce = new ObjectMapper().readTree(jwtPayload).get("c_nonce").asText(); + + if (testCaseName.contains("_Invalid_C_nonce_")) + nonce = "jwt_payload.c_nonce123"; + if (testCaseName.contains("_Empty_Typ_")) + typ = ""; + if (testCaseName.contains("_Invalid_Typ_")) + typ = "openid4vci-123@proof+jwt"; - claimsSet = new JWTClaimsSet.Builder().audience(tempUrl) - .claim("nonce", new ObjectMapper().readTree(jwtPayload).get("c_nonce").asText()) - .issuer(clientId).issueTime(new Date()) - .expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); + claimsSet = new JWTClaimsSet.Builder().audience(tempUrl).claim("nonce", nonce).issuer(clientId) + .issueTime(new Date()).expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); + + if (testCaseName.contains("_Missing_Typ_")) { + signedJWT = new SignedJWT( + new JWSHeader.Builder(JWSAlgorithm.RS256).jwk(jwkHeader).build(), + claimsSet); + } else { + signedJWT = new SignedJWT( + new JWSHeader.Builder(JWSAlgorithm.RS256).type(new JOSEObjectType(typ)).jwk(jwkHeader).build(), + claimsSet); } - SignedJWT signedJWT = new SignedJWT(new JWSHeader.Builder(JWSAlgorithm.RS256) - .type(new JOSEObjectType(typ)).jwk(jwkHeader).build(), claimsSet); signedJWT.sign(signer); proofJWT = signedJWT.serialize(); diff --git a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml index d12428f507e..eb2d981ed49 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -32,39 +32,6 @@ AuthenticateUserVCI: } }' - ESignet_AuthenticateUserVCI_Vid_Otp_Valid_Smoke: - endPoint: /v1/esignet/authorization/authenticate - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI - outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", - "authFactorType" : "OTP", - "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_EMAIL$", - "sendOtp":{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$", - "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], - "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", - "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" - } - }' - output: '{ - "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", - "maskedEmail": "$IGNORE$" - } -}' - ESignet_AuthenticateUserVCI_uin_Otp_1stLang_Valid_Smoke: endPoint: /v1/esignet/authorization/authenticate role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 26d7abc3479..33f1184f249 100644 --- a/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -15,22 +15,6 @@ AuthorizationCodeVCI: output: '{ }' - ESignet_AuthorizationCode_VCI_Vid_All_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/auth-code - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - validityCheckRequired: true - inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI - outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult - input: '{ - "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", - "requestTime": "$TIMESTAMP$", - "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$" -}' - output: '{ -}' - ESignet_AuthorizationCode_VCI_uin_All_1stLang_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml index 6f172d373f5..a80fc64300b 100644 --- a/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/GenerateTokenVCI/GenerateTokenVCI.yml @@ -19,26 +19,6 @@ GenerateTokenVCI: "token_type": "Bearer" }' - ESignet_GenerateTokenVCI_Vid_Valid_Smoke_sid: - endPoint: /v1/esignet/oauth/v2/token - role: resident - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI - outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult - input: '{ - "grant_type": "authorization_code", - "code": "$ID:AuthorizationCode_VCI_Vid_All_Valid_Smoke_sid_code$", - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", - "client_assertion": "$CLIENT_ASSERTION_JWK$", - "redirect_uri": "$IDPREDIRECTURI$", - "code_verifier": "$CODEVERIFIER$" -}' - output: '{ - "token_type": "Bearer" -}' - ESignet_GenerateTokenVCI_uin_1stLang_Valid_Smoke_sid: endPoint: /v1/esignet/oauth/v2/token role: resident diff --git a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml index fac3004558e..b6d48197f51 100644 --- a/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCI/GetCredential/GetCredential.yml @@ -78,24 +78,4 @@ GetCredential: }' output: '{ "error":"vci_exchange_failed" -}' - - ESignet_GetCredential_Vid_IdpAccessToken_all_Valid_Smoke: - endPoint: /v1/esignet/vci/credential - role: resident - checkErrorsOnlyInResponse: true - restMethod: post - validityCheckRequired: true - inputTemplate: esignet/VCI/GetCredential/GetCredential - outputTemplate: esignet/VCI/GetCredential/GetCredentialResult - input: '{ - "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "idpAccessToken": "$ID:GenerateTokenVCI_Vid_Valid_Smoke_sid_access_token$", - "format": "ldp_vc", - "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], - "@context": [{context: "$VCICONTEXTURL$"}], - "proof_type": "jwt", - "proof_jwt": "$PROOFJWT$" -}' - output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index 4b9af83b95b..4767e52a453 100644 --- a/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -23,32 +23,6 @@ OAuthDetailsRequestVCI: }' output: '{ -}' - - ESignet_OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid: - endPoint: /v1/esignet/authorization/v2/oauth-details - role: resident - restMethod: post - checkErrorsOnlyInResponse: true - inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI - outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult - input: '{ - "requestTime": "$TIMESTAMP$", - "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", - "scope": "mosip_identity_vc_ldp", - "responseType": "code", - "redirectUri": "$IDPREDIRECTURI$", - "display": "popup", - "prompt": "login", - "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", - "nonce": "973eieljzng", - "state": "eree2311", - "claimsLocales": "en", - "codeChallenge": "$CODECHALLENGE$", - "codeChallengeMethod": "S256" -}' - output: '{ - }' ESignet_OAuthDetailsRequest_VCI_uin_1stLang_all_Valid_Smoke_sid: diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml index 856e6da21ee..e8494f7a152 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml @@ -559,4 +559,67 @@ GetCredentialNegTC: }' output: '{ "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Empty_Typ_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Typ_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_Typ_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.hbs b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.hbs new file mode 100644 index 00000000000..887633e1120 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.hbs @@ -0,0 +1,15 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "individualId": "{{individualId}}", + "challengeList" : [ + { + "authFactorType" : "{{authFactorType}}", + "challenge" : "{{challenge}}", + "format": "alpha-numeric" + } + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml new file mode 100644 index 00000000000..8051033a6ce --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -0,0 +1,33 @@ +AuthenticateUserVCIVid: + ESignet_AuthenticateUserVCI_Vid_Otp_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs new file mode 100644 index 00000000000..491dca1ba1f --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs @@ -0,0 +1,19 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "acceptedClaims": [ + {{#each acceptedClaims}} + "{{claim}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "permittedAuthorizeScopes": [ + {{#each permittedAuthorizeScopes}} + "{{scope}}" + {{#unless @last}},{{/unless}} + {{/each}} + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml new file mode 100644 index 00000000000..fdc44a331b8 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -0,0 +1,16 @@ +AuthorizationCodeVCIVid: + ESignet_AuthorizationCode_VCI_Vid_All_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.hbs b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.hbs new file mode 100644 index 00000000000..c425e67650b --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.hbs @@ -0,0 +1,9 @@ +{ + "grant_type": "{{grant_type}}", + "code": "{{code}}", + "client_id": "{{client_id}}", + "client_assertion_type": "{{client_assertion_type}}", + "client_assertion": "{{client_assertion}}", + "redirect_uri": "{{redirect_uri}}", + "code_verifier": "{{code_verifier}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml new file mode 100644 index 00000000000..7444ba4672a --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml @@ -0,0 +1,20 @@ +GenerateTokenVCIVid: + ESignet_GenerateTokenVCI_Vid_Valid_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_Vid_All_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCIResult.hbs new file mode 100644 index 00000000000..c323e20a77e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCIResult.hbs @@ -0,0 +1,3 @@ +{ + "token_type": "{{token_type}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.hbs b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.hbs new file mode 100644 index 00000000000..74e5e52857d --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.hbs @@ -0,0 +1,23 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : { + "type": [ + {{#each type}} + "{{types}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "@context": [ + {{#each @context}} + "{{context}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + }, + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml new file mode 100644 index 00000000000..dd5c5399fe2 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml @@ -0,0 +1,20 @@ +GetCredentialVid: + ESignet_GetCredential_Vid_IdpAccessToken_all_Valid_Smoke: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCIVid/GetCredential/GetCredential + outputTemplate: esignet/VCIVid/GetCredential/GetCredentialResult + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_Vid_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialEmptyCredDef.hbs b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialEmptyCredDef.hbs new file mode 100644 index 00000000000..5d7d77356e9 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialEmptyCredDef.hbs @@ -0,0 +1,10 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : {}, + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoCredDef.hbs b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoCredDef.hbs new file mode 100644 index 00000000000..66fef780c5d --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoCredDef.hbs @@ -0,0 +1,10 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : "{{credential_definition}}", + "proof": { + "proof_type": "{{proof_type}}", + "jwt": "{{proof_jwt}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoProof.hbs b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoProof.hbs new file mode 100644 index 00000000000..761bada3bcf --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialNoProof.hbs @@ -0,0 +1,19 @@ +{ + "client_id": "{{client_id}}", + "idpAccessToken": "{{idpAccessToken}}", + "format": "{{format}}", + "credential_definition" : { + "type": [ + {{#each type}} + "{{types}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "@context": [ + {{#each @context}} + "{{context}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialResult.hbs b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredentialResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs new file mode 100644 index 00000000000..6dec068b531 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs @@ -0,0 +1,17 @@ +{ + "requestTime": "{{requestTime}}", + "request": { + "clientId": "{{clientId}}", + "scope": "{{scope}}", + "responseType": "{{responseType}}", + "redirectUri": "{{redirectUri}}", + "display": "{{display}}", + "prompt": "{{prompt}}", + "acrValues": "{{acrValues}}", + "nonce" : "{{nonce}}", + "state" : "{{state}}", + "claimsLocales" : "{{claimsLocales}}", + "codeChallenge" : "{{codeChallenge}}", + "codeChallengeMethod" : "{{codeChallengeMethod}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml new file mode 100644 index 00000000000..ecfed1081b9 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -0,0 +1,26 @@ +OAuthDetailsRequestVCIVid: + ESignet_OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file From d9bab089f1f6fc868295fee2e4c6ffd497b6f965 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 25 Sep 2023 20:13:07 +0530 Subject: [PATCH 178/204] MOSIP-29454 --- ...tionalTest-classpath-arg-1695652238739.txt | 1 + .../apirig/admin/fw/util/AdminTestUtil.java | 52 ++++++++++++++++++- .../resources/config/valueMapping.properties | 4 +- .../preReg/createPrereg/createPrereg.yml | 21 +++++++- 4 files changed, 75 insertions(+), 3 deletions(-) create mode 100644 automationtests/.temp-MosipFunctionalTest-classpath-arg-1695652238739.txt diff --git a/automationtests/.temp-MosipFunctionalTest-classpath-arg-1695652238739.txt b/automationtests/.temp-MosipFunctionalTest-classpath-arg-1695652238739.txt new file mode 100644 index 00000000000..0fc13dd5a9b --- /dev/null +++ b/automationtests/.temp-MosipFunctionalTest-classpath-arg-1695652238739.txt @@ -0,0 +1 @@ +-classpath D:\Mosip_Automation_Test\MOSIP_FUNCTIONAL_TESTS\mosip-functional-tests\automationtests\target\test-classes;D:\Mosip_Automation_Test\MOSIP_FUNCTIONAL_TESTS\mosip-functional-tests\automationtests\target\classes;C:\Users\Sohan.Dey\.m2\repository\com\opencsv\opencsv\4.1\opencsv-4.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\commons\commons-lang3\3.6\commons-lang3-3.6.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\commons\commons-text\1.1\commons-text-1.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\ibm\icu\icu4j\63.1\icu4j-63.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\keycloak\keycloak-admin-client\17.0.1\keycloak-admin-client-17.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\keycloak\keycloak-core\17.0.1\keycloak-core-17.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\keycloak\keycloak-common\17.0.1\keycloak-common-17.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\resteasy\resteasy-client\3.13.2.Final\resteasy-client-3.13.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\spec\javax\ws\rs\jboss-jaxrs-api_2.1_spec\2.0.1.Final\jboss-jaxrs-api_2.1_spec-2.0.1.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\resteasy\resteasy-jaxrs\3.13.2.Final\resteasy-jaxrs-3.13.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\reactivestreams\reactive-streams\1.0.3\reactive-streams-1.0.3.jar;C:\Users\Sohan.Dey\.m2\repository\jakarta\validation\jakarta.validation-api\2.0.2\jakarta.validation-api-2.0.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\spec\javax\annotation\jboss-annotations-api_1.3_spec\2.0.1.Final\jboss-annotations-api_1.3_spec-2.0.1.Final.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\activation\jakarta.activation\1.2.1\jakarta.activation-1.2.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\stephenc\jcip\jcip-annotations\1.0-1\jcip-annotations-1.0-1.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\resteasy\resteasy-multipart-provider\3.13.2.Final\resteasy-multipart-provider-3.13.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\mail\jakarta.mail\1.6.5\jakarta.mail-1.6.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\james\apache-mime4j\0.6\apache-mime4j-0.6.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\resteasy\resteasy-jackson2-provider\3.13.2.Final\resteasy-jackson2-provider-3.13.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\jaxrs\jackson-jaxrs-json-provider\2.10.5\jackson-jaxrs-json-provider-2.10.5.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\jaxrs\jackson-jaxrs-base\2.10.5\jackson-jaxrs-base-2.10.5.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\fge\json-patch\1.9\json-patch-1.9.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\fge\jackson-coreutils\1.6\jackson-coreutils-1.6.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\fge\msg-simple\1.1\msg-simple-1.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\fge\btf\1.2\btf-1.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\resteasy\resteasy-jaxb-provider\3.13.2.Final\resteasy-jaxb-provider-3.13.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\spec\javax\xml\bind\jboss-jaxb-api_2.3_spec\2.0.0.Final\jboss-jaxb-api_2.3_spec-2.0.0.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\javassist\javassist\3.25.0-GA\javassist-3.25.0-GA.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\jknack\handlebars\3.0.0\handlebars-3.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\antlr\antlr4-runtime\4.5.1-1\antlr4-runtime-4.5.1-1.jar;C:\Users\Sohan.Dey\.m2\repository\org\mozilla\rhino\1.7R4\rhino-1.7R4.jar;C:\Users\Sohan.Dey\.m2\repository\org\slf4j\slf4j-api\1.6.4\slf4j-api-1.6.4.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\commons\commons-collections4\4.3\commons-collections4-4.3.jar;C:\Users\Sohan.Dey\.m2\repository\io\jsonwebtoken\jjwt\0.6.0\jjwt-0.6.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\flipkart\zjsonpatch\zjsonpatch\0.4.7\zjsonpatch-0.4.7.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk\1.11.368\aws-java-sdk-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-dlm\1.11.368\aws-java-sdk-dlm-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\jmespath-java\1.11.368\jmespath-java-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-macie\1.11.368\aws-java-sdk-macie-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-eks\1.11.368\aws-java-sdk-eks-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mediatailor\1.11.368\aws-java-sdk-mediatailor-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-neptune\1.11.368\aws-java-sdk-neptune-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-pi\1.11.368\aws-java-sdk-pi-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-iot1clickprojects\1.11.368\aws-java-sdk-iot1clickprojects-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-iot1clickdevices\1.11.368\aws-java-sdk-iot1clickdevices-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-iotanalytics\1.11.368\aws-java-sdk-iotanalytics-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-acmpca\1.11.368\aws-java-sdk-acmpca-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-secretsmanager\1.11.368\aws-java-sdk-secretsmanager-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-fms\1.11.368\aws-java-sdk-fms-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-connect\1.11.368\aws-java-sdk-connect-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-transcribe\1.11.368\aws-java-sdk-transcribe-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-autoscalingplans\1.11.368\aws-java-sdk-autoscalingplans-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-workmail\1.11.368\aws-java-sdk-workmail-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-servicediscovery\1.11.368\aws-java-sdk-servicediscovery-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloud9\1.11.368\aws-java-sdk-cloud9-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-serverlessapplicationrepository\1.11.368\aws-java-sdk-serverlessapplicationrepository-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-alexaforbusiness\1.11.368\aws-java-sdk-alexaforbusiness-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-resourcegroups\1.11.368\aws-java-sdk-resourcegroups-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-comprehend\1.11.368\aws-java-sdk-comprehend-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-translate\1.11.368\aws-java-sdk-translate-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-sagemaker\1.11.368\aws-java-sdk-sagemaker-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-iotjobsdataplane\1.11.368\aws-java-sdk-iotjobsdataplane-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-sagemakerruntime\1.11.368\aws-java-sdk-sagemakerruntime-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-kinesisvideo\1.11.368\aws-java-sdk-kinesisvideo-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-codec-http\4.1.17.Final\netty-codec-http-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-codec\4.1.17.Final\netty-codec-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-handler\4.1.17.Final\netty-handler-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-buffer\4.1.17.Final\netty-buffer-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-common\4.1.17.Final\netty-common-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-transport\4.1.17.Final\netty-transport-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-resolver\4.1.17.Final\netty-resolver-4.1.17.Final.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-appsync\1.11.368\aws-java-sdk-appsync-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-guardduty\1.11.368\aws-java-sdk-guardduty-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mq\1.11.368\aws-java-sdk-mq-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mediaconvert\1.11.368\aws-java-sdk-mediaconvert-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mediastore\1.11.368\aws-java-sdk-mediastore-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mediastoredata\1.11.368\aws-java-sdk-mediastoredata-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-medialive\1.11.368\aws-java-sdk-medialive-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mediapackage\1.11.368\aws-java-sdk-mediapackage-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-costexplorer\1.11.368\aws-java-sdk-costexplorer-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-pricing\1.11.368\aws-java-sdk-pricing-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mobile\1.11.368\aws-java-sdk-mobile-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudhsmv2\1.11.368\aws-java-sdk-cloudhsmv2-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-glue\1.11.368\aws-java-sdk-glue-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-migrationhub\1.11.368\aws-java-sdk-migrationhub-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-dax\1.11.368\aws-java-sdk-dax-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-greengrass\1.11.368\aws-java-sdk-greengrass-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-athena\1.11.368\aws-java-sdk-athena-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-marketplaceentitlement\1.11.368\aws-java-sdk-marketplaceentitlement-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-codestar\1.11.368\aws-java-sdk-codestar-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-lexmodelbuilding\1.11.368\aws-java-sdk-lexmodelbuilding-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-resourcegroupstaggingapi\1.11.368\aws-java-sdk-resourcegroupstaggingapi-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-pinpoint\1.11.368\aws-java-sdk-pinpoint-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-xray\1.11.368\aws-java-sdk-xray-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-opsworkscm\1.11.368\aws-java-sdk-opsworkscm-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-support\1.11.368\aws-java-sdk-support-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-simpledb\1.11.368\aws-java-sdk-simpledb-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-servicecatalog\1.11.368\aws-java-sdk-servicecatalog-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-servermigration\1.11.368\aws-java-sdk-servermigration-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-simpleworkflow\1.11.368\aws-java-sdk-simpleworkflow-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-storagegateway\1.11.368\aws-java-sdk-storagegateway-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-route53\1.11.368\aws-java-sdk-route53-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-s3\1.11.368\aws-java-sdk-s3-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-importexport\1.11.368\aws-java-sdk-importexport-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-sts\1.11.368\aws-java-sdk-sts-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-sqs\1.11.368\aws-java-sdk-sqs-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-rds\1.11.368\aws-java-sdk-rds-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-redshift\1.11.368\aws-java-sdk-redshift-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-elasticbeanstalk\1.11.368\aws-java-sdk-elasticbeanstalk-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-glacier\1.11.368\aws-java-sdk-glacier-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-iam\1.11.368\aws-java-sdk-iam-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-datapipeline\1.11.368\aws-java-sdk-datapipeline-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-elasticloadbalancing\1.11.368\aws-java-sdk-elasticloadbalancing-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-elasticloadbalancingv2\1.11.368\aws-java-sdk-elasticloadbalancingv2-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-emr\1.11.368\aws-java-sdk-emr-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-elasticache\1.11.368\aws-java-sdk-elasticache-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-elastictranscoder\1.11.368\aws-java-sdk-elastictranscoder-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-ec2\1.11.368\aws-java-sdk-ec2-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-dynamodb\1.11.368\aws-java-sdk-dynamodb-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-sns\1.11.368\aws-java-sdk-sns-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-budgets\1.11.368\aws-java-sdk-budgets-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudtrail\1.11.368\aws-java-sdk-cloudtrail-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudwatch\1.11.368\aws-java-sdk-cloudwatch-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-logs\1.11.368\aws-java-sdk-logs-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-events\1.11.368\aws-java-sdk-events-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cognitoidentity\1.11.368\aws-java-sdk-cognitoidentity-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cognitosync\1.11.368\aws-java-sdk-cognitosync-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-directconnect\1.11.368\aws-java-sdk-directconnect-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudformation\1.11.368\aws-java-sdk-cloudformation-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudfront\1.11.368\aws-java-sdk-cloudfront-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-clouddirectory\1.11.368\aws-java-sdk-clouddirectory-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-kinesis\1.11.368\aws-java-sdk-kinesis-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-opsworks\1.11.368\aws-java-sdk-opsworks-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-ses\1.11.368\aws-java-sdk-ses-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-autoscaling\1.11.368\aws-java-sdk-autoscaling-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudsearch\1.11.368\aws-java-sdk-cloudsearch-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudwatchmetrics\1.11.368\aws-java-sdk-cloudwatchmetrics-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-codedeploy\1.11.368\aws-java-sdk-codedeploy-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-codepipeline\1.11.368\aws-java-sdk-codepipeline-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-kms\1.11.368\aws-java-sdk-kms-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-config\1.11.368\aws-java-sdk-config-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-lambda\1.11.368\aws-java-sdk-lambda-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-ecs\1.11.368\aws-java-sdk-ecs-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-ecr\1.11.368\aws-java-sdk-ecr-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cloudhsm\1.11.368\aws-java-sdk-cloudhsm-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-ssm\1.11.368\aws-java-sdk-ssm-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-workspaces\1.11.368\aws-java-sdk-workspaces-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-machinelearning\1.11.368\aws-java-sdk-machinelearning-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-directory\1.11.368\aws-java-sdk-directory-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-efs\1.11.368\aws-java-sdk-efs-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-codecommit\1.11.368\aws-java-sdk-codecommit-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-devicefarm\1.11.368\aws-java-sdk-devicefarm-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-elasticsearch\1.11.368\aws-java-sdk-elasticsearch-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-waf\1.11.368\aws-java-sdk-waf-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-marketplacecommerceanalytics\1.11.368\aws-java-sdk-marketplacecommerceanalytics-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-inspector\1.11.368\aws-java-sdk-inspector-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-iot\1.11.368\aws-java-sdk-iot-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-api-gateway\1.11.368\aws-java-sdk-api-gateway-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-acm\1.11.368\aws-java-sdk-acm-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-gamelift\1.11.368\aws-java-sdk-gamelift-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-dms\1.11.368\aws-java-sdk-dms-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-marketplacemeteringservice\1.11.368\aws-java-sdk-marketplacemeteringservice-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-cognitoidp\1.11.368\aws-java-sdk-cognitoidp-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-discovery\1.11.368\aws-java-sdk-discovery-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-applicationautoscaling\1.11.368\aws-java-sdk-applicationautoscaling-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-snowball\1.11.368\aws-java-sdk-snowball-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-rekognition\1.11.368\aws-java-sdk-rekognition-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-polly\1.11.368\aws-java-sdk-polly-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-lightsail\1.11.368\aws-java-sdk-lightsail-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-stepfunctions\1.11.368\aws-java-sdk-stepfunctions-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-health\1.11.368\aws-java-sdk-health-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-costandusagereport\1.11.368\aws-java-sdk-costandusagereport-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-codebuild\1.11.368\aws-java-sdk-codebuild-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-appstream\1.11.368\aws-java-sdk-appstream-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-shield\1.11.368\aws-java-sdk-shield-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-batch\1.11.368\aws-java-sdk-batch-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-lex\1.11.368\aws-java-sdk-lex-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-mechanicalturkrequester\1.11.368\aws-java-sdk-mechanicalturkrequester-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-organizations\1.11.368\aws-java-sdk-organizations-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-workdocs\1.11.368\aws-java-sdk-workdocs-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-core\1.11.368\aws-java-sdk-core-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\software\amazon\ion\ion-java\1.0.2\ion-java-1.0.2.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\dataformat\jackson-dataformat-cbor\2.6.7\jackson-dataformat-cbor-2.6.7.jar;C:\Users\Sohan.Dey\.m2\repository\joda-time\joda-time\2.8.1\joda-time-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-models\1.11.368\aws-java-sdk-models-1.11.368.jar;C:\Users\Sohan.Dey\.m2\repository\com\amazonaws\aws-java-sdk-swf-libraries\1.11.22\aws-java-sdk-swf-libraries-1.11.22.jar;C:\Users\Sohan.Dey\.m2\repository\com\aventstack\extentreports\3.0.0\extentreports-3.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\freemarker\freemarker\2.3.23\freemarker-2.3.23.jar;C:\Users\Sohan.Dey\.m2\repository\org\mongodb\mongodb-driver\3.3.0\mongodb-driver-3.3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\mongodb\bson\3.3.0\bson-3.3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\mongodb\mongodb-driver-core\3.3.0\mongodb-driver-core-3.3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\httpcomponents\httpmime\4.5.2\httpmime-4.5.2.jar;C:\Users\Sohan.Dey\.m2\repository\com\relevantcodes\extentreports\2.41.2\extentreports-2.41.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\jsoup\jsoup\1.8.3\jsoup-1.8.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\xerial\sqlite-jdbc\3.8.11.1\sqlite-jdbc-3.8.11.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\jayway\jsonpath\json-path\2.4.0\json-path-2.4.0.jar;C:\Users\Sohan.Dey\.m2\repository\net\minidev\json-smart\2.3\json-smart-2.3.jar;C:\Users\Sohan.Dey\.m2\repository\net\minidev\accessors-smart\1.2\accessors-smart-1.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\ow2\asm\asm\5.0.4\asm-5.0.4.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-model\3.3.9\maven-model-3.3.9.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\plexus\plexus-utils\3.0.22\plexus-utils-3.0.22.jar;C:\Users\Sohan.Dey\.m2\repository\io\rest-assured\rest-assured\3.0.7\rest-assured-3.0.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\groovy\groovy\2.4.12\groovy-2.4.12.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\groovy\groovy-xml\2.4.12\groovy-xml-2.4.12.jar;C:\Users\Sohan.Dey\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\hamcrest\hamcrest-library\1.3\hamcrest-library-1.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\ccil\cowan\tagsoup\tagsoup\1.2.1\tagsoup-1.2.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\rest-assured\json-path\3.0.7\json-path-3.0.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\groovy\groovy-json\2.4.12\groovy-json-2.4.12.jar;C:\Users\Sohan.Dey\.m2\repository\io\rest-assured\rest-assured-common\3.0.7\rest-assured-common-3.0.7.jar;C:\Users\Sohan.Dey\.m2\repository\io\rest-assured\xml-path\3.0.7\xml-path-3.0.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\testng\testng\6.11\testng-6.11.jar;C:\Users\Sohan.Dey\.m2\repository\com\beust\jcommander\1.64\jcommander-1.64.jar;C:\Users\Sohan.Dey\.m2\repository\org\yaml\snakeyaml\1.17\snakeyaml-1.17.jar;C:\Users\Sohan.Dey\.m2\repository\org\zeroturnaround\zt-zip\1.13\zt-zip-1.13.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\core\jackson-core\2.10.1\jackson-core-2.10.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\core\jackson-annotations\2.9.5\jackson-annotations-2.9.5.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\core\jackson-databind\2.10.5\jackson-databind-2.10.5.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\dataformat\jackson-dataformat-xml\2.9.5\jackson-dataformat-xml-2.9.5.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\module\jackson-module-jaxb-annotations\2.9.5\jackson-module-jaxb-annotations-2.9.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\woodstox\stax2-api\3.1.4\stax2-api-3.1.4.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\woodstox\woodstox-core\5.0.3\woodstox-core-5.0.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\json\json\20180130\json-20180130.jar;C:\Users\Sohan.Dey\.m2\repository\com\googlecode\json-simple\json-simple\1.1.1\json-simple-1.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\junit\junit\4.10\junit-4.10.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\code\gson\gson\2.8.4\gson-2.8.4.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\plugins\maven-assembly-plugin\3.1.0\maven-assembly-plugin-3.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-plugin-api\3.0\maven-plugin-api-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\sisu\sisu-inject-plexus\1.4.2\sisu-inject-plexus-1.4.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\sisu\sisu-inject-bean\1.4.2\sisu-inject-bean-1.4.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\sisu\sisu-guice\2.1.7\sisu-guice-2.1.7-noaop.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-core\3.0\maven-core-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-settings\3.0\maven-settings-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-settings-builder\3.0\maven-settings-builder-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-repository-metadata\3.0\maven-repository-metadata-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-model-builder\3.0\maven-model-builder-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-aether-provider\3.0\maven-aether-provider-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\aether\aether-impl\1.7\aether-impl-1.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\aether\aether-spi\1.7\aether-spi-1.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\aether\aether-api\1.7\aether-api-1.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\aether\aether-util\1.7\aether-util-1.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\plexus\plexus-classworlds\2.2.3\plexus-classworlds-2.2.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\plexus\plexus-component-annotations\1.5.5\plexus-component-annotations-1.5.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\plexus\plexus-sec-dispatcher\1.3\plexus-sec-dispatcher-1.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\plexus\plexus-cipher\1.4\plexus-cipher-1.4.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-artifact\3.0\maven-artifact-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\shared\maven-common-artifact-filters\3.0.1\maven-common-artifact-filters-3.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\shared\maven-shared-utils\3.1.0\maven-shared-utils-3.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\shared\maven-artifact-transfer\0.9.0\maven-artifact-transfer-0.9.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\plexus\plexus-interpolation\1.24\plexus-interpolation-1.24.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\plexus\plexus-archiver\3.5\plexus-archiver-3.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\commons\commons-compress\1.14\commons-compress-1.14.jar;C:\Users\Sohan.Dey\.m2\repository\org\iq80\snappy\snappy\0.4\snappy-0.4.jar;C:\Users\Sohan.Dey\.m2\repository\org\tukaani\xz\1.6\xz-1.6.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\shared\file-management\3.0.0\file-management-3.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\shared\maven-shared-io\3.0.0\maven-shared-io-3.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-compat\3.0\maven-compat-3.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\wagon\wagon-provider-api\2.10\wagon-provider-api-2.10.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\shared\maven-filtering\3.1.1\maven-filtering-3.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\sonatype\plexus\plexus-build-api\0.0.7\plexus-build-api-0.0.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\plexus\plexus-io\3.0.0\plexus-io-3.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\maven\maven-archiver\3.2.0\maven-archiver-3.2.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\guava\guava\19.0\guava-19.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\hibernate\hibernate-core\5.4.2.Final\hibernate-core-5.4.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\logging\jboss-logging\3.3.2.Final\jboss-logging-3.3.2.Final.jar;C:\Users\Sohan.Dey\.m2\repository\javax\persistence\javax.persistence-api\2.2\javax.persistence-api-2.2.jar;C:\Users\Sohan.Dey\.m2\repository\net\bytebuddy\byte-buddy\1.9.10\byte-buddy-1.9.10.jar;C:\Users\Sohan.Dey\.m2\repository\antlr\antlr\2.7.7\antlr-2.7.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\spec\javax\transaction\jboss-transaction-api_1.2_spec\1.1.1.Final\jboss-transaction-api_1.2_spec-1.1.1.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\jboss\jandex\2.0.5.Final\jandex-2.0.5.Final.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\classmate\1.3.4\classmate-1.3.4.jar;C:\Users\Sohan.Dey\.m2\repository\javax\activation\javax.activation-api\1.2.0\javax.activation-api-1.2.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\dom4j\dom4j\2.1.1\dom4j-2.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\hibernate\common\hibernate-commons-annotations\5.1.0.Final\hibernate-commons-annotations-5.1.0.Final.jar;C:\Users\Sohan.Dey\.m2\repository\javax\xml\bind\jaxb-api\2.3.1\jaxb-api-2.3.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\glassfish\jaxb\jaxb-runtime\2.3.1\jaxb-runtime-2.3.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\glassfish\jaxb\txw2\2.3.1\txw2-2.3.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\istack\istack-commons-runtime\3.0.7\istack-commons-runtime-3.0.7.jar;C:\Users\Sohan.Dey\.m2\repository\org\jvnet\staxex\stax-ex\1.8\stax-ex-1.8.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\xml\fastinfoset\FastInfoset\1.2.15\FastInfoset-1.2.15.jar;C:\Users\Sohan.Dey\.m2\repository\commons-beanutils\commons-beanutils\1.9.2\commons-beanutils-1.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\commons-logging\commons-logging\1.1.1\commons-logging-1.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\commons-collections\commons-collections\3.2.1\commons-collections-3.2.1.jar;C:\Users\Sohan.Dey\.m2\repository\javax\validation\validation-api\2.0.1.Final\validation-api-2.0.1.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\swagger\swagger-annotations\1.5.20\swagger-annotations-1.5.20.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.9.5\jackson-datatype-jsr310-2.9.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\postgresql\postgresql\42.2.2\postgresql-42.2.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\slf4j\slf4j-log4j12\1.6.2\slf4j-log4j12-1.6.2.jar;C:\Users\Sohan.Dey\.m2\repository\log4j\log4j\1.2.16\log4j-1.2.16.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\logging\log4j\log4j-api\2.11.1\log4j-api-2.11.1.jar;C:\Users\Sohan.Dey\.m2\repository\net\lingala\zip4j\zip4j\1.3.2\zip4j-1.3.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\httpcomponents\httpclient\4.5.3\httpclient-4.5.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\httpcomponents\httpcore\4.4.6\httpcore-4.4.6.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-client\2.8.1\hadoop-client-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-common\2.8.1\hadoop-common-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\commons-cli\commons-cli\1.2\commons-cli-1.2.jar;C:\Users\Sohan.Dey\.m2\repository\xmlenc\xmlenc\0.52\xmlenc-0.52.jar;C:\Users\Sohan.Dey\.m2\repository\commons-net\commons-net\3.1\commons-net-3.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\mortbay\jetty\jetty-sslengine\6.1.26\jetty-sslengine-6.1.26.jar;C:\Users\Sohan.Dey\.m2\repository\javax\servlet\jsp\jsp-api\2.1\jsp-api-2.1.jar;C:\Users\Sohan.Dey\.m2\repository\commons-configuration\commons-configuration\1.6\commons-configuration-1.6.jar;C:\Users\Sohan.Dey\.m2\repository\commons-digester\commons-digester\1.8\commons-digester-1.8.jar;C:\Users\Sohan.Dey\.m2\repository\commons-beanutils\commons-beanutils-core\1.8.0\commons-beanutils-core-1.8.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\jackson\jackson-core-asl\1.9.13\jackson-core-asl-1.9.13.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\jackson\jackson-mapper-asl\1.9.13\jackson-mapper-asl-1.9.13.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\avro\avro\1.7.4\avro-1.7.4.jar;C:\Users\Sohan.Dey\.m2\repository\com\thoughtworks\paranamer\paranamer\2.3\paranamer-2.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\xerial\snappy\snappy-java\1.0.4.1\snappy-java-1.0.4.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\protobuf\protobuf-java\2.5.0\protobuf-java-2.5.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-auth\2.8.1\hadoop-auth-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\directory\server\apacheds-kerberos-codec\2.0.0-M15\apacheds-kerberos-codec-2.0.0-M15.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\directory\server\apacheds-i18n\2.0.0-M15\apacheds-i18n-2.0.0-M15.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\directory\api\api-asn1-api\1.0.0-M20\api-asn1-api-1.0.0-M20.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\directory\api\api-util\1.0.0-M20\api-util-1.0.0-M20.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\curator\curator-framework\2.7.1\curator-framework-2.7.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\curator\curator-client\2.7.1\curator-client-2.7.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\curator\curator-recipes\2.7.1\curator-recipes-2.7.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\code\findbugs\jsr305\3.0.0\jsr305-3.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\htrace\htrace-core4\4.0.1-incubating\htrace-core4-4.0.1-incubating.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\zookeeper\zookeeper\3.4.6\zookeeper-3.4.6.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty\3.7.0.Final\netty-3.7.0.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-hdfs\2.8.1\hadoop-hdfs-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-hdfs-client\2.8.1\hadoop-hdfs-client-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\squareup\okhttp\okhttp\2.4.0\okhttp-2.4.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\squareup\okio\okio\1.4.0\okio-1.4.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-mapreduce-client-app\2.8.1\hadoop-mapreduce-client-app-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-mapreduce-client-common\2.8.1\hadoop-mapreduce-client-common-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-yarn-client\2.8.1\hadoop-yarn-client-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-yarn-server-common\2.8.1\hadoop-yarn-server-common-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-mapreduce-client-shuffle\2.8.1\hadoop-mapreduce-client-shuffle-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\fusesource\leveldbjni\leveldbjni-all\1.8\leveldbjni-all-1.8.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-yarn-api\2.8.1\hadoop-yarn-api-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-mapreduce-client-core\2.8.1\hadoop-mapreduce-client-core-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-yarn-common\2.8.1\hadoop-yarn-common-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\javax\servlet\servlet-api\2.5\servlet-api-2.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\mortbay\jetty\jetty-util\6.1.26\jetty-util-6.1.26.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\jersey\jersey-core\1.9\jersey-core-1.9.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\jersey\jersey-client\1.9\jersey-client-1.9.jar;C:\Users\Sohan.Dey\.m2\repository\org\codehaus\jackson\jackson-xc\1.9.13\jackson-xc-1.9.13.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-mapreduce-client-jobclient\2.8.1\hadoop-mapreduce-client-jobclient-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\hadoop\hadoop-annotations\2.8.1\hadoop-annotations-2.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\bouncycastle\bcprov-jdk15on\1.56\bcprov-jdk15on-1.56.jar;C:\Users\Sohan.Dey\.m2\repository\commons-codec\commons-codec\1.11\commons-codec-1.11.jar;C:\Users\Sohan.Dey\.m2\repository\commons-io\commons-io\2.6\commons-io-2.6.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\zxing\core\3.3.3\core-3.3.3.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\zxing\javase\2.0\javase-2.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\hamcrest\hamcrest-all\1.3\hamcrest-all-1.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\velocity\velocity\1.7\velocity-1.7.jar;C:\Users\Sohan.Dey\.m2\repository\commons-lang\commons-lang\2.4\commons-lang-2.4.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\html2pdf\2.0.0\html2pdf-2.0.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\forms\7.1.0\forms-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\kernel\7.1.0\kernel-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\io\7.1.0\io-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\layout\7.1.0\layout-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\itextpdf\5.5.13\itextpdf-5.5.13.jar;C:\Users\Sohan.Dey\.m2\repository\javax\mail\javax.mail-api\1.6.2\javax.mail-api-1.6.2.jar;D:\Mosip_Automation_Test\MOSIP_FUNCTIONAL_TESTS\mosip-functional-tests\authentication-demo-service\target\classes;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-web\2.0.2.RELEASE\spring-boot-starter-web-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-json\2.0.2.RELEASE\spring-boot-starter-json-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.9.5\jackson-datatype-jdk8-2.9.5.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\module\jackson-module-parameter-names\2.9.5\jackson-module-parameter-names-2.9.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-tomcat\2.0.2.RELEASE\spring-boot-starter-tomcat-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\tomcat\embed\tomcat-embed-el\8.5.31\tomcat-embed-el-8.5.31.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\tomcat\embed\tomcat-embed-websocket\8.5.31\tomcat-embed-websocket-8.5.31.jar;C:\Users\Sohan.Dey\.m2\repository\org\hibernate\validator\hibernate-validator\6.0.9.Final\hibernate-validator-6.0.9.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-web\5.0.6.RELEASE\spring-web-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-webmvc\5.0.6.RELEASE\spring-webmvc-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-expression\5.0.6.RELEASE\spring-expression-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-test\2.0.2.RELEASE\spring-boot-starter-test-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-test\2.0.2.RELEASE\spring-boot-test-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-test-autoconfigure\2.0.2.RELEASE\spring-boot-test-autoconfigure-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\assertj\assertj-core\3.9.1\assertj-core-3.9.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\skyscreamer\jsonassert\1.5.0\jsonassert-1.5.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\vaadin\external\google\android-json\0.0.20131108.vaadin1\android-json-0.0.20131108.vaadin1.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-core\5.0.6.RELEASE\spring-core-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-jcl\5.0.6.RELEASE\spring-jcl-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-test\5.0.6.RELEASE\spring-test-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\xmlunit\xmlunit-core\2.5.1\xmlunit-core-2.5.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-swagger-ui\2.9.2\springfox-swagger-ui-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-spring-web\2.9.2\springfox-spring-web-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-swagger2\2.9.2\springfox-swagger2-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-spi\2.9.2\springfox-spi-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-core\2.9.2\springfox-core-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-schema\2.9.2\springfox-schema-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\springfox\springfox-swagger-common\2.9.2\springfox-swagger-common-2.9.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\plugin\spring-plugin-core\1.2.0.RELEASE\spring-plugin-core-1.2.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\plugin\spring-plugin-metadata\1.2.0.RELEASE\spring-plugin-metadata-1.2.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\mapstruct\mapstruct\1.2.0.Final\mapstruct-1.2.0.Final.jar;C:\Users\Sohan.Dey\.m2\repository\javax\ws\rs\javax.ws.rs-api\2.0\javax.ws.rs-api-2.0.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\authentication\authentication-core\1.2.0.1-B3\authentication-core-1.2.0.1-B3.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-cache\2.0.2.RELEASE\spring-boot-starter-cache-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-context-support\5.0.6.RELEASE\spring-context-support-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\com\machinezoo\sourceafis\sourceafis\3.4.0\sourceafis-3.4.0.jar;C:\Users\Sohan.Dey\.m2\repository\net\sf\trove4j\trove4j\3.0.3\trove4j-3.0.3.jar;C:\Users\Sohan.Dey\.m2\repository\com\machinezoo\noexception\noexception\1.3.2\noexception-1.3.2.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\mhshams\jnbis\2.0.1\jnbis-2.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\sanselan\sanselan\0.97-incubator\sanselan-0.97-incubator.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\idrepository\id-repository-core\1.2.0.1-B1\id-repository-core-1.2.0.1-B1.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-biosdk-provider\1.2.0.1-B1\kernel-biosdk-provider-1.2.0.1-B1.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-biometrics-api\1.2.0.1-B1\kernel-biometrics-api-1.2.0.1-B1.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-demographics-api\1.2.0.1-B1\kernel-demographics-api-1.2.0.1-B1.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-webflux\2.0.2.RELEASE\spring-boot-starter-webflux-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-reactor-netty\2.0.2.RELEASE\spring-boot-starter-reactor-netty-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\io\projectreactor\ipc\reactor-netty\0.7.7.RELEASE\reactor-netty-0.7.7.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-handler-proxy\4.1.24.Final\netty-handler-proxy-4.1.24.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-codec-socks\4.1.24.Final\netty-codec-socks-4.1.24.Final.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-transport-native-epoll\4.1.24.Final\netty-transport-native-epoll-4.1.24.Final-linux-x86_64.jar;C:\Users\Sohan.Dey\.m2\repository\io\netty\netty-transport-native-unix-common\4.1.24.Final\netty-transport-native-unix-common-4.1.24.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-webflux\5.0.6.RELEASE\spring-webflux-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\synchronoss\cloud\nio-multipart-parser\1.1.0\nio-multipart-parser-1.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\synchronoss\cloud\nio-stream-storage\1.1.3\nio-stream-storage-1.1.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\springdoc\springdoc-openapi-ui\1.5.10\springdoc-openapi-ui-1.5.10.jar;C:\Users\Sohan.Dey\.m2\repository\org\springdoc\springdoc-openapi-webmvc-core\1.5.10\springdoc-openapi-webmvc-core-1.5.10.jar;C:\Users\Sohan.Dey\.m2\repository\org\springdoc\springdoc-openapi-common\1.5.10\springdoc-openapi-common-1.5.10.jar;C:\Users\Sohan.Dey\.m2\repository\io\swagger\core\v3\swagger-models\2.1.10\swagger-models-2.1.10.jar;C:\Users\Sohan.Dey\.m2\repository\io\swagger\core\v3\swagger-annotations\2.1.10\swagger-annotations-2.1.10.jar;C:\Users\Sohan.Dey\.m2\repository\io\swagger\core\v3\swagger-integration\2.1.10\swagger-integration-2.1.10.jar;C:\Users\Sohan.Dey\.m2\repository\io\swagger\core\v3\swagger-core\2.1.10\swagger-core-2.1.10.jar;C:\Users\Sohan.Dey\.m2\repository\jakarta\xml\bind\jakarta.xml.bind-api\2.3.2\jakarta.xml.bind-api-2.3.2.jar;C:\Users\Sohan.Dey\.m2\repository\jakarta\activation\jakarta.activation-api\1.2.1\jakarta.activation-api-1.2.1.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\dataformat\jackson-dataformat-yaml\2.12.1\jackson-dataformat-yaml-2.12.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\github\classgraph\classgraph\4.8.69\classgraph-4.8.69.jar;C:\Users\Sohan.Dey\.m2\repository\org\webjars\swagger-ui\3.51.1\swagger-ui-3.51.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\webjars\webjars-locator-core\0.45\webjars-locator-core-0.45.jar;C:\Users\Sohan.Dey\.m2\repository\commons-fileupload\commons-fileupload\1.4\commons-fileupload-1.4.jar;C:\Users\Sohan.Dey\.m2\repository\org\mockito\mockito-core\2.23.4\mockito-core-2.23.4.jar;C:\Users\Sohan.Dey\.m2\repository\net\bytebuddy\byte-buddy-agent\1.9.3\byte-buddy-agent-1.9.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\objenesis\objenesis\2.6\objenesis-2.6.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-websubclient-api\1.2.0.1-SNAPSHOT\kernel-websubclient-api-1.2.0.1-SNAPSHOT.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-aspects\5.0.6.RELEASE\spring-aspects-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar;C:\Users\Sohan.Dey\.m2\repository\org\owasp\encoder\encoder\1.2.3\encoder-1.2.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-actuator\2.0.2.RELEASE\spring-boot-starter-actuator-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-actuator-autoconfigure\2.0.2.RELEASE\spring-boot-actuator-autoconfigure-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-actuator\2.0.2.RELEASE\spring-boot-actuator-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\tensorflow\tensorflow\1.12.0\tensorflow-1.12.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\tensorflow\libtensorflow\1.12.0\libtensorflow-1.12.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\tensorflow\libtensorflow_jni\1.12.0\libtensorflow_jni-1.12.0.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-templatemanager-velocity\1.2.0.1-SNAPSHOT\kernel-templatemanager-velocity-1.2.0.1-SNAPSHOT.jar;C:\Users\Sohan.Dey\.m2\repository\javax\servlet\javax.servlet-api\4.0.1\javax.servlet-api-4.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-starter-config\2.0.0.RELEASE\spring-cloud-starter-config-2.0.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-starter\2.0.0.RELEASE\spring-cloud-starter-2.0.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-context\2.0.0.RELEASE\spring-cloud-context-2.0.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\security\spring-security-crypto\5.0.6.RELEASE\spring-security-crypto-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-commons\2.0.0.RELEASE\spring-cloud-commons-2.0.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\security\spring-security-rsa\1.0.5.RELEASE\spring-security-rsa-1.0.5.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-config-client\2.0.0.RELEASE\spring-cloud-config-client-2.0.0.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\jai-imageio\jai-imageio-jpeg2000\1.3.0\jai-imageio-jpeg2000-1.3.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\jai-imageio\jai-imageio-core\1.3.0\jai-imageio-core-1.3.0.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-keymanager-service\1.2.0.1-SNAPSHOT\kernel-keymanager-service-1.2.0.1-SNAPSHOT-lib.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\security\spring-security-test\5.0.5.RELEASE\spring-security-test-5.0.5.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\security\spring-security-core\5.0.5.RELEASE\spring-security-core-5.0.5.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-pdfgenerator-itext\1.2.0.1-SNAPSHOT\kernel-pdfgenerator-itext-1.2.0.1-SNAPSHOT.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\barcodes\7.1.0\barcodes-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\font-asian\7.1.0\font-asian-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\hyph\7.1.0\hyph-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\pdfa\7.1.0\pdfa-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\sign\7.1.0\sign-7.1.0.jar;C:\Users\Sohan.Dey\.m2\repository\com\itextpdf\tool\xmlworker\5.5.13\xmlworker-5.5.13.jar;C:\Users\Sohan.Dey\.m2\repository\org\bouncycastle\bcpkix-jdk15on\1.66\bcpkix-jdk15on-1.66.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-data-jpa\2.0.2.RELEASE\spring-boot-starter-data-jpa-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-jdbc\2.0.2.RELEASE\spring-boot-starter-jdbc-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\com\zaxxer\HikariCP\2.7.9\HikariCP-2.7.9.jar;C:\Users\Sohan.Dey\.m2\repository\com\h2database\h2\1.4.197\h2-1.4.197.jar;C:\Users\Sohan.Dey\.m2\repository\com\github\microsoft\TSS.Java\0.3.0\TSS.Java-0.3.0.jar;C:\Users\Sohan.Dey\.m2\repository\net\java\dev\jna\jna\4.4.0\jna-4.4.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\cache2k\cache2k-api\2.4.1.Final\cache2k-api-2.4.1.Final.jar;C:\Users\Sohan.Dey\.m2\repository\org\cache2k\cache2k-core\2.4.1.Final\cache2k-core-2.4.1.Final.jar;C:\Users\Sohan.Dey\.m2\repository\com\nimbusds\nimbus-jose-jwt\9.14\nimbus-jose-jwt-9.14.jar;C:\Users\Sohan.Dey\.m2\repository\io\projectreactor\reactor-core\3.1.7.RELEASE\reactor-core-3.1.7.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-core\1.2.0.1-B1\kernel-core-1.2.0.1-B1.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter\2.0.2.RELEASE\spring-boot-starter-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot\2.0.2.RELEASE\spring-boot-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.0.2.RELEASE\spring-boot-autoconfigure-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-logging\2.0.2.RELEASE\spring-boot-starter-logging-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\logging\log4j\log4j-to-slf4j\2.10.0\log4j-to-slf4j-2.10.0.jar;C:\Users\Sohan.Dey\.m2\repository\javax\annotation\javax.annotation-api\1.3.2\javax.annotation-api-1.3.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\data\spring-data-jpa\2.0.7.RELEASE\spring-data-jpa-2.0.7.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\data\spring-data-commons\2.0.7.RELEASE\spring-data-commons-2.0.7.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-orm\5.0.6.RELEASE\spring-orm-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-jdbc\5.0.6.RELEASE\spring-jdbc-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-context\5.0.6.RELEASE\spring-context-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-aop\5.0.6.RELEASE\spring-aop-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-tx\5.0.6.RELEASE\spring-tx-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\spring-beans\5.0.6.RELEASE\spring-beans-5.0.6.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\aspectj\aspectjrt\1.8.12\aspectjrt-1.8.12.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-security\2.0.2.RELEASE\spring-boot-starter-security-2.0.2.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\security\spring-security-config\5.0.5.RELEASE\spring-security-config-5.0.5.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\security\spring-security-web\5.0.5.RELEASE\spring-security-web-5.0.5.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\javax\transaction\javax.transaction-api\1.3\javax.transaction-api-1.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\commons\commons-math3\3.6.1\commons-math3-3.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\javax\interceptor\javax.interceptor-api\1.2\javax.interceptor-api-1.2.jar;C:\Users\Sohan.Dey\.m2\repository\com\google\code\findbugs\annotations\3.0.1\annotations-3.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\net\jcip\jcip-annotations\1.0\jcip-annotations-1.0.jar;C:\Users\Sohan.Dey\.m2\repository\io\swagger\swagger-models\1.5.21\swagger-models-1.5.21.jar;C:\Users\Sohan.Dey\.m2\repository\com\auth0\java-jwt\3.8.1\java-jwt-3.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\micrometer\micrometer-core\1.4.2\micrometer-core-1.4.2.jar;C:\Users\Sohan.Dey\.m2\repository\org\hdrhistogram\HdrHistogram\2.1.12\HdrHistogram-2.1.12.jar;C:\Users\Sohan.Dey\.m2\repository\org\latencyutils\LatencyUtils\2.0.3\LatencyUtils-2.0.3.jar;C:\Users\Sohan.Dey\.m2\repository\io\micrometer\micrometer-registry-prometheus\1.4.2\micrometer-registry-prometheus-1.4.2.jar;C:\Users\Sohan.Dey\.m2\repository\io\prometheus\simpleclient_common\0.8.1\simpleclient_common-0.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\prometheus\simpleclient\0.8.1\simpleclient-0.8.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\slf4j\jul-to-slf4j\1.7.25\jul-to-slf4j-1.7.25.jar;C:\Users\Sohan.Dey\.m2\repository\org\slf4j\jcl-over-slf4j\1.7.25\jcl-over-slf4j-1.7.25.jar;C:\Users\Sohan.Dey\.m2\repository\javax\activation\activation\1.1\activation-1.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-starter-sleuth\2.0.4.RELEASE\spring-cloud-starter-sleuth-2.0.4.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\boot\spring-boot-starter-aop\2.0.9.RELEASE\spring-boot-starter-aop-2.0.9.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\cloud\spring-cloud-sleuth-core\2.0.4.RELEASE\spring-cloud-sleuth-core-2.0.4.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave\5.6.1\brave-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\zipkin2\zipkin\2.12.0\zipkin-2.12.0.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\reporter2\zipkin-reporter\2.7.14\zipkin-reporter-2.7.14.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-context-log4j2\5.6.1\brave-context-log4j2-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-spring-web\5.6.1\brave-instrumentation-spring-web-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-http\5.6.1\brave-instrumentation-http-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-spring-rabbit\5.6.1\brave-instrumentation-spring-rabbit-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-kafka-clients\5.6.1\brave-instrumentation-kafka-clients-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-httpclient\5.6.1\brave-instrumentation-httpclient-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-httpasyncclient\5.6.1\brave-instrumentation-httpasyncclient-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-spring-webmvc\5.6.1\brave-instrumentation-spring-webmvc-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\io\zipkin\brave\brave-instrumentation-servlet\5.6.1\brave-instrumentation-servlet-5.6.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\tomcat\embed\tomcat-embed-core\8.5.55\tomcat-embed-core-8.5.55.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\tomcat\tomcat-annotations-api\8.5.55\tomcat-annotations-api-8.5.55.jar;C:\Users\Sohan.Dey\.m2\repository\org\springframework\retry\spring-retry\1.2.1.RELEASE\spring-retry-1.2.1.RELEASE.jar;C:\Users\Sohan.Dey\.m2\repository\com\fasterxml\jackson\module\jackson-module-afterburner\2.12.0\jackson-module-afterburner-2.12.0.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-registration-packet-manager\1.1.5.3\kernel-registration-packet-manager-1.1.5.3.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-keygenerator-bouncycastle\1.1.5.3\kernel-keygenerator-bouncycastle-1.1.5.3.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-cbeffutil-api\1.1.5.3\kernel-cbeffutil-api-1.1.5.3.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-logger-logback\1.1.5.3\kernel-logger-logback-1.1.5.3.jar;C:\Users\Sohan.Dey\.m2\repository\net\logstash\logback\logstash-logback-encoder\6.4\logstash-logback-encoder-6.4.jar;C:\Users\Sohan.Dey\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\Sohan.Dey\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\Sohan.Dey\.m2\repository\ch\qos\logback\logback-access\1.2.3\logback-access-1.2.3.jar;C:\Users\Sohan.Dey\.m2\repository\io\mosip\kernel\kernel-crypto-jce\1.1.5.3\kernel-crypto-jce-1.1.5.3.jar;C:\Users\Sohan.Dey\.m2\repository\org\bitbucket\b_c\jose4j\0.6.5\jose4j-0.6.5.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\wink\wink-json4j-provider\1.1.2-incubating\wink-json4j-provider-1.1.2-incubating.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\wink\wink-common\1.1.2-incubating\wink-common-1.1.2-incubating.jar;C:\Users\Sohan.Dey\.m2\repository\com\sun\xml\bind\jaxb-impl\2.2.1.1\jaxb-impl-2.2.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\geronimo\specs\geronimo-annotation_1.1_spec\1.0\geronimo-annotation_1.1_spec-1.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\wink\wink-json4j\1.1.2-incubating\wink-json4j-1.1.2-incubating.jar;C:\Users\Sohan.Dey\.m2\repository\javax\ws\rs\jsr311-api\1.1.1\jsr311-api-1.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\checkerframework\checker-qual\2.9.0\checker-qual-2.9.0.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\activemq\activemq-broker\5.15.9\activemq-broker-5.15.9.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\activemq\activemq-client\5.15.9\activemq-client-5.15.9.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\geronimo\specs\geronimo-jms_1.1_spec\1.1.1\geronimo-jms_1.1_spec-1.1.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\fusesource\hawtbuf\hawtbuf\1.11\hawtbuf-1.11.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\geronimo\specs\geronimo-j2ee-management_1.1_spec\1.0.1\geronimo-j2ee-management_1.1_spec-1.0.1.jar;C:\Users\Sohan.Dey\.m2\repository\org\apache\activemq\activemq-openwire-legacy\5.15.9\activemq-openwire-legacy-5.15.9.jar;C:\Users\Sohan.Dey\.m2\repository\org\projectlombok\lombok\1.18.8\lombok-1.18.8.jar \ No newline at end of file diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index a7418bf7959..121fcff9a36 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4463,6 +4463,23 @@ public static String generateHbsForPrereg(boolean isItUpdate) { logger.info(objIDJson2); JSONArray objIDJson1 = objIDJson.getJSONArray(GlobalConstants.REQUIRED); logger.info(objIDJson1); + boolean emailFieldAdditionallyAdded=false; + boolean phoneFieldAdditionallyAdded=false; + String phone = getValueFromAuthActuator("json-property", "phone_number"); + String result = phone.replaceAll("\\[\"|\"\\]", ""); + + if (!isElementPresent(objIDJson1, result)) { + objIDJson1.put(result); + phoneFieldAdditionallyAdded=true; + } + + //System.out.println("result is:" + result); + String email = getValueFromAuthActuator("json-property", "emailId"); + String emailResult = email.replaceAll("\\[\"|\"\\]", ""); + if (!isElementPresent(objIDJson1, emailResult)) { + objIDJson1.put(emailResult); + emailFieldAdditionallyAdded=true; + } ArrayList list = new ArrayList<>(); @@ -4472,6 +4489,10 @@ public static String generateHbsForPrereg(boolean isItUpdate) { list.add(objIDJson1.get(i).toString()); } } + list.remove(GlobalConstants.RESIDENCESTATUS); + list.remove("addressCopy"); + list.remove("proofOfAddress"); + list.remove(GlobalConstants.RESIDENCESTATUS); list.add(GlobalConstants.RESIDENCESTATUS); if (list.contains(GlobalConstants.PROOFOFIDENTITY)) { list.remove(GlobalConstants.PROOFOFIDENTITY); @@ -4533,12 +4554,14 @@ public static String generateHbsForPrereg(boolean isItUpdate) { fileWriter2.write(jArray.toString()); fileWriter2.write("\t"); + if (jArray.toString().contains(GlobalConstants.RESIDENCESTATUS) || objIDJson3.contains(GlobalConstants.RESIDENCESTATUS)) { fileWriter2.write("\n\t \n}\n}\n}\n}\n"); } else { fileWriter2.write("\n\t \n"); - } + } + fileWriter2.close(); @@ -4556,6 +4579,33 @@ public static String generateHbsForPrereg(boolean isItUpdate) { else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { fileWriter2.write("\t \"" + objIDJson3 + "\":" + " " + "" + "" + schemaVersion + "" + "\n"); } + + else if (objIDJson3.equals(result)) { + + if (phoneFieldAdditionallyAdded) { + fileWriter2.write( + ",\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + "\n"); + } else { + fileWriter2.write( + "\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + } + + /* + * fileWriter2 .write("\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + + * objIDJson3 + "}}\"" + ",\n"); + */ + } + + else if (objIDJson3.equals(emailResult)) { + if (emailFieldAdditionallyAdded) { + fileWriter2.write( + ",\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + "\n"); + } else { + fileWriter2.write( + "\t \"" + objIDJson3 + "\":" + " " + "\"" + "{{" + objIDJson3 + "}}\"" + ",\n"); + } + + } else { fileWriter2 diff --git a/automationtests/src/main/resources/config/valueMapping.properties b/automationtests/src/main/resources/config/valueMapping.properties index e3247b8ec2a..c9b1c8ebb6e 100644 --- a/automationtests/src/main/resources/config/valueMapping.properties +++ b/automationtests/src/main/resources/config/valueMapping.properties @@ -30,4 +30,6 @@ bloodGroup=O Miss-TitleFromServer=MIS Mr-TitleFromServer=MIR Mrs-TitleFromServer=MRS -Miss-TitleFromServer.=MIS \ No newline at end of file +Miss-TitleFromServer.=MIS +addressCopy=TEST_ADDRESSLINE3 +proofOfAddress=TEST_ADDRESSLINE2 \ No newline at end of file diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml index 0dde123bc62..80a43d15497 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml +++ b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml @@ -28,7 +28,8 @@ CreatePrereg: outputTemplate: preReg/createPrereg/createPreregResult input: '{ "postalCode": "14022", - "phone": "8249742850", + "phone": "9876543210", + "mobileno": "9876543210", "email": "goku@technoforte.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -49,6 +50,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@technoforte.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -70,6 +72,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@technoforte.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -90,6 +93,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@technoforte.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -110,6 +114,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -130,6 +135,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -149,6 +155,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -173,6 +180,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -197,6 +205,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -221,6 +230,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -245,6 +255,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -269,6 +280,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "so.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -293,6 +305,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -317,6 +330,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -341,6 +355,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -365,6 +380,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -389,6 +405,7 @@ CreatePrereg: input: '{ "postalCode": "14022", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@hogwarts.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -415,6 +432,7 @@ CreatePrereg: input: '{ "postalCode": "14", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@technoforte.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", @@ -441,6 +459,7 @@ CreatePrereg: input: '{ "postalCode": "$34!", "phone": "8249742850", + "mobileno": "8249742850", "email": "goku@technoforte.co.in", "IDSchemaVersion": $SCHEMAVERSION$, "dateOfBirth": "1996/01/01", From a1c495f798d4d01df7a57336816c98eb5e08d98b Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Mon, 25 Sep 2023 21:13:05 +0530 Subject: [PATCH 179/204] add resident test case&esignet --- .../KycBioAuth/KycBioAuthResultKycStatus.hbs | 5 + .../UpdatePartnerCertificate.yml | 15 + .../updatePartnerCertificate.hbs | 7 + .../updatePartnerCertificateResult.hbs | 3 + .../resident/AddIdentity/AddIdentity.yml | 88 ++++++ .../GenerateVID/createGenerateVID.yml | 267 ++++++++++++++++++ 6 files changed, 385 insertions(+) create mode 100644 automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResultKycStatus.hbs create mode 100644 automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/UpdatePartnerCertificate.yml create mode 100644 automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificate.hbs create mode 100644 automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificateResult.hbs diff --git a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResultKycStatus.hbs b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResultKycStatus.hbs new file mode 100644 index 00000000000..742a72ac67d --- /dev/null +++ b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuthResultKycStatus.hbs @@ -0,0 +1,5 @@ +{ + "response": { + "kycStatus": {{kycStatus}} + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/UpdatePartnerCertificate.yml b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/UpdatePartnerCertificate.yml new file mode 100644 index 00000000000..9432fd305dc --- /dev/null +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/UpdatePartnerCertificate.yml @@ -0,0 +1,15 @@ +updatePartnerCertificate: + ESignet_updatePartnerCertificate_StatusCode_AuthDemoUrl_All_Valid_Smoke: + endPoint: /v1/identity/updatePartnerCertificate + role: partner + restMethod: post + inputTemplate: esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificate + outputTemplate: esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificateResult + input: '{ + "certData": "$ID:UploadPartnerCert_Misp_Valid_Smoke_sid_signedCertificateData$", + "partnerType": "MISP", + "partnerName": "$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$", + "keyFileNameByPartnerName": "true", + "moduleName": "esignet" + }' + output: "200" diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificate.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificate.hbs new file mode 100644 index 00000000000..db10966a68b --- /dev/null +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificate.hbs @@ -0,0 +1,7 @@ +{ + "certData": "{{certData}}", + "partnerType": "{{partnerType}}", + "partnerName": "{{partnerName}}", + "keyFileNameByPartnerName": "{{keyFileNameByPartnerName}}", + "moduleName": "{{moduleName}}" +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificateResult.hbs b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificateResult.hbs new file mode 100644 index 00000000000..0e0dcd235c4 --- /dev/null +++ b/automationtests/src/main/resources/esignet/PmsIntegration/UpdatePartnerCertificate/updatePartnerCertificateResult.hbs @@ -0,0 +1,3 @@ +{ + +} \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml index 11b323f6509..487a3f94347 100644 --- a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml @@ -609,4 +609,92 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + + Resident_AddIdentity_withInValid_DOB_Neg: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/error + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "15/04/1998", + "postalCode": "14022", + "email": "Resident_AddIdentity_withInValid_DOB_Neg@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "errors": [ + { + "errorCode": "IDR-IDC-002" + } + ] +}' + + Resident_AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "Resident_AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + + Resident_AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "Resident_AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index dc9d93deb56..4d8f42729a8 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -2673,4 +2673,271 @@ GenerateVID: "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", "maskedEmail": "$IGNORE$" } +}' + + Resident_Generate_Temporary_VID_ONE_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Temporary_VID_TWO_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Temporary_VID_Three_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Temporary_VID_FOUR_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Temporary_VID_FIVE_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Temporary_VID_SIX_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Perpetual_VID_Valid_First_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } + + +}' + + Resident_Generate_Perpetual_VID_SecondTime_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } + }' \ No newline at end of file From ff3fd7a8c3baccb51c16fdc4cf769a212902e377 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 26 Sep 2023 09:59:38 +0530 Subject: [PATCH 180/204] MOSIP-29513 --- .../testNgXmlFiles/esignetSuite.xml | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/automationtests/testNgXmlFiles/esignetSuite.xml b/automationtests/testNgXmlFiles/esignetSuite.xml index 52d7f98a630..c90115c943f 100644 --- a/automationtests/testNgXmlFiles/esignetSuite.xml +++ b/automationtests/testNgXmlFiles/esignetSuite.xml @@ -468,6 +468,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From ccc2687783929e8756b70fcf51b487b27560e587 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Tue, 26 Sep 2023 11:03:03 +0530 Subject: [PATCH 181/204] key update --- .../java/io/mosip/testrig/apirig/service/BaseTestCase.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 9a7e5594544..d85dba0e02d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -562,9 +562,13 @@ public static List getLanguageList() { optionalLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), section, "mosip.optional-languages"); + logger.info("optionalLanguages from env:" + optionalLanguages); + mandatoryLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), - section, "mosip.mandatoryLanguages from env:" + mandatoryLanguages); + section, "mosip.mandatory-languages" + mandatoryLanguages); + + logger.info("mandatoryLanguages from env:" + optionalLanguages); } catch(Exception e) { From eab55a5a9fc2f839ea414674be76b2d60f2c00e1 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 26 Sep 2023 12:14:18 +0530 Subject: [PATCH 182/204] Language issue fixes --- .../java/io/mosip/testrig/apirig/service/BaseTestCase.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index d85dba0e02d..52d56e71596 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -566,9 +566,9 @@ public static List getLanguageList() { logger.info("optionalLanguages from env:" + optionalLanguages); mandatoryLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), - section, "mosip.mandatory-languages" + mandatoryLanguages); + section, "mosip.mandatory-languages"); - logger.info("mandatoryLanguages from env:" + optionalLanguages); + logger.info("mandatoryLanguages from env:" + mandatoryLanguages); } catch(Exception e) { From 973a0e014798b7cfbfe327a616d8946bc0e3982a Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 26 Sep 2023 13:34:30 +0530 Subject: [PATCH 183/204] Language issue fixes --- .../idRepository/AddIdentity/AddIdentity.yml | 43 +++++++++++++++++++ .../resources/ida/AddIdentity/AddIdentity.yml | 30 +++++++++++++ .../resident/AddIdentity/AddIdentity.yml | 25 +++++++++++ 3 files changed, 98 insertions(+) diff --git a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml index 3acfe9cc9d0..99d280e63e9 100644 --- a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml @@ -9,6 +9,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -41,6 +42,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -73,6 +75,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -105,6 +108,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -138,6 +142,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -171,6 +176,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -203,6 +209,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -236,6 +243,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -268,6 +276,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "@@GGHHDR", @@ -305,6 +314,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -343,6 +353,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -380,6 +391,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -417,6 +429,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -455,6 +468,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -492,6 +506,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -529,6 +544,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -566,6 +582,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -603,6 +620,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -640,6 +658,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -676,6 +695,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -709,6 +729,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -746,6 +767,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -783,6 +805,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -819,6 +842,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -855,6 +879,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -888,6 +913,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -925,6 +951,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -962,6 +989,7 @@ AddIdentity: "value": "dbfkxjf", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1000,6 +1028,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1037,6 +1066,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1074,6 +1104,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1111,6 +1142,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1148,6 +1180,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1185,6 +1218,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1222,6 +1256,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1255,6 +1290,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1288,6 +1324,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1321,6 +1358,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1354,6 +1392,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1387,6 +1426,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1420,6 +1460,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1453,6 +1494,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -1486,6 +1528,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", diff --git a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml index 34090b544c1..2565c0ed782 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml @@ -9,6 +9,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -36,6 +37,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "2023/09/09", @@ -63,6 +65,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -90,6 +93,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -117,6 +121,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -144,6 +149,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -171,6 +177,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -198,6 +205,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -225,6 +233,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -252,6 +261,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -279,6 +289,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -306,6 +317,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -339,6 +351,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -372,6 +385,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -405,6 +419,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -438,6 +453,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -471,6 +487,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -503,6 +520,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -535,6 +553,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -568,6 +587,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -600,6 +620,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -632,6 +653,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -665,6 +687,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -697,6 +720,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -729,6 +753,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -762,6 +787,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -796,6 +822,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", @@ -829,6 +856,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", @@ -863,6 +891,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", @@ -891,6 +920,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1970/07/08", diff --git a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml index 487a3f94347..dbff54d3968 100644 --- a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml @@ -9,6 +9,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -36,6 +37,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -63,6 +65,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -90,6 +93,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -117,6 +121,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -144,6 +149,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -171,6 +177,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -198,6 +205,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -226,6 +234,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "IDSchemaVersion": "$SCHEMAVERSION$", "UIN": "$UIN$", @@ -255,6 +264,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "IDSchemaVersion": "$SCHEMAVERSION$", "UIN": "$UIN$", @@ -284,6 +294,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "IDSchemaVersion": "$SCHEMAVERSION$", "UIN": "$UIN$", @@ -313,6 +324,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -341,6 +353,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -369,6 +382,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -397,6 +411,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -425,6 +440,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -453,6 +469,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -481,6 +498,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -509,6 +527,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -537,6 +556,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -565,6 +585,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -593,6 +614,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -621,6 +643,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "15/04/1998", @@ -653,6 +676,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", @@ -681,6 +705,7 @@ AddIdentity: "value": "$BIOVALUE$", "id": "mosip.id.create", "registrationId": "$RID$", + "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", "dateOfBirth": "1992/04/15", From 94a5718fdc1b9db281115c69091de42cfe2c64c3 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Tue, 26 Sep 2023 17:11:26 +0530 Subject: [PATCH 184/204] removed mosip from name --- .../java/io/mosip/testrig/apirig/service/BaseTestCase.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 52d56e71596..9b83d797d89 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -555,9 +555,9 @@ public static List getLanguageList() { String optionalLanguages=null; String mandatoryLanguages=null; if (isTargetEnvLTS()) - section = "/mosip/mosip-config/application-default.properties"; + section = "/mosip-config/application-default.properties"; else - section = "/mosip/mosip-config/sandbox/admin-mz.properties"; + section = "/mosip-config/sandbox/admin-mz.properties"; try { optionalLanguages = getValueFromActuators(propsKernel.getProperty("actuatorAdminEndpoint"), From cfd36fe1b843606addb3f16344586dabe542ede6 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Tue, 26 Sep 2023 17:33:36 +0530 Subject: [PATCH 185/204] removed mosip key --- .../io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java | 4 ++-- .../java/io/mosip/testrig/apirig/service/BaseTestCase.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 68a6aa60e65..890b4088942 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4885,9 +4885,9 @@ public static Certificate convertToCertificate(String certData) { public static int getOtpExpTimeFromActuator() { if (otpExpTime.isEmpty()) { - String section = "configService:https://github.com/mosip/mosip-config/application-default.properties"; + String section = "/mosip-config/application-default.properties"; if (!BaseTestCase.isTargetEnvLTS()) - section = "configService:https://github.com/mosip/mosip-config/sandbox/application-lts.properties"; + section = "/mosip-config/sandbox/application-lts.properties"; Response response = null; org.json.JSONObject responseJson = null; JSONArray responseArray = null; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 9b83d797d89..12bbdc047e0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -613,9 +613,9 @@ public static List getSupportedIdTypesValueFromActuator() { return supportedIdType; } - String section = "configService:https://github.com/mosip/mosip-config/id-authentication-default.properties"; + String section = "/mosip-config/id-authentication-default.properties"; if (!BaseTestCase.isTargetEnvLTS()) - section = "configService:https://github.com/mosip/mosip-config/sandbox/id-authentication-lts.properties"; + section = "/mosip-config/sandbox/id-authentication-lts.properties"; Response response = null; From bd4aafafc15a90a64123c7829c729d70f6f39fa2 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 26 Sep 2023 19:11:06 +0530 Subject: [PATCH 186/204] MOSIP-29513 --- .../apirig/admin/fw/util/AdminTestUtil.java | 24 ++- .../VCINegTC/GetCredential/GetCredential.yml | 168 ++++++++++++++++++ 2 files changed, 187 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 68a6aa60e65..4dfe15ef058 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3264,25 +3264,39 @@ public static String signJWK(String clientId, String accessToken, RSAKey jwkKey, if (testCaseName.contains("_Invalid_C_nonce_")) nonce = "jwt_payload.c_nonce123"; - if (testCaseName.contains("_Empty_Typ_")) + else if (testCaseName.contains("_Empty_C_nonce_")) + nonce = ""; + else if (testCaseName.contains("_SpaceVal_C_nonce_")) + nonce = " "; + else if (testCaseName.contains("_Empty_Typ_")) typ = ""; - if (testCaseName.contains("_Invalid_Typ_")) + else if (testCaseName.contains("_SpaceVal_Typ_")) + typ = " "; + else if (testCaseName.contains("_Invalid_Typ_")) typ = "openid4vci-123@proof+jwt"; + else if (testCaseName.contains("_Invalid_JwkHeader_")) + jwkHeader = RSAKey.parse(getJWKKey(oidcJWK2)).toPublicJWK(); + else if (testCaseName.contains("_Invalid_Aud_")) + tempUrl = "sdfaf"; + else if (testCaseName.contains("_Invalid_Iss_")) + clientId = "sdfdsg"; + else if (testCaseName.contains("_Invalid_Exp_")) + idTokenExpirySecs = 0; claimsSet = new JWTClaimsSet.Builder().audience(tempUrl).claim("nonce", nonce).issuer(clientId) .issueTime(new Date()).expirationTime(new Date(new Date().getTime() + idTokenExpirySecs)).build(); if (testCaseName.contains("_Missing_Typ_")) { + signedJWT = new SignedJWT(new JWSHeader.Builder(JWSAlgorithm.RS256).jwk(jwkHeader).build(), claimsSet); + } else if (testCaseName.contains("_Missing_JwkHeader_")) { signedJWT = new SignedJWT( - new JWSHeader.Builder(JWSAlgorithm.RS256).jwk(jwkHeader).build(), - claimsSet); + new JWSHeader.Builder(JWSAlgorithm.RS256).type(new JOSEObjectType(typ)).build(), claimsSet); } else { signedJWT = new SignedJWT( new JWSHeader.Builder(JWSAlgorithm.RS256).type(new JOSEObjectType(typ)).jwk(jwkHeader).build(), claimsSet); } - signedJWT.sign(signer); proofJWT = signedJWT.serialize(); } catch (Exception e) { diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml index e8494f7a152..a6b39199d78 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml @@ -561,6 +561,48 @@ GetCredentialNegTC: "error":"invalid_proof" }' + ESignet_GetCredential_uin_IdpAccessToken_Empty_C_nonce_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_C_nonce_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + ESignet_GetCredential_uin_IdpAccessToken_Empty_Typ_Neg: endPoint: /v1/esignet/vci/credential role: resident @@ -582,6 +624,27 @@ GetCredentialNegTC: "error":"invalid_proof" }' + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Typ_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Typ_Neg: endPoint: /v1/esignet/vci/credential role: resident @@ -622,4 +685,109 @@ GetCredentialNegTC: }' output: '{ "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_JwkHeader_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Missing_JwkHeader_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Aud_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Iss_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Exp_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" }' \ No newline at end of file From 51f31d059b62726050d70ca14a131a352f9b4cf4 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Tue, 26 Sep 2023 19:27:46 +0530 Subject: [PATCH 187/204] MOSIP-28071 --- .../esignet/KycBioAuth/KycBioAuth.yml | 189 ++++++++++++++++++ .../resources/esignet/KycDemoAuth/KycAuth.yml | 17 -- .../esignet/KycDemoAuth/KycCreateAuthReq.yml | 23 --- .../resident/AuthLock/createAuthLock.yml | 33 +++ .../resident/AuthUnLock/createAuthUnLock.yml | 33 +++ .../RequestCredentials/ReqCredential.yml | 178 ++++++++++++++++- .../GenerateVID/createGenerateVID.yml | 14 +- .../resources/resident/SendOTP/SendOTP.yml | 19 ++ 8 files changed, 462 insertions(+), 44 deletions(-) delete mode 100644 automationtests/src/main/resources/esignet/KycDemoAuth/KycAuth.yml delete mode 100644 automationtests/src/main/resources/esignet/KycDemoAuth/KycCreateAuthReq.yml diff --git a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml index 5c3d73368a0..1d9b4816575 100644 --- a/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml +++ b/automationtests/src/main/resources/esignet/KycBioAuth/KycBioAuth.yml @@ -395,4 +395,193 @@ KycBioAuth: "errorCode": "IDA-BIA-001" } ] +}' + + Esignet_KycBioAuth_uin_null_MispLk_Neg: + endPoint: /v1/identity/createAuthRequest?id=$ID:AddIdentity_KycAuth_smoke_Pos_UIN$&idType=UIN&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/KycBioAuth/KycBioAuth + outputTemplate: esignet/KycBioAuth/KycBioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$", + "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/null​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" +}' + output: '{ + "authStatus": false +}' + + Esignet_KycBioAuth_vid_null_MispLk_Neg: + endPoint: /v1/identity/createAuthRequest?id=$ID:Generate_Perpetual_VID_Kyc_Valid_Smoke_sid_vid$&idType=VID&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/KycBioAuth/KycBioAuth + outputTemplate: esignet/KycBioAuth/KycBioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$", + "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/null​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" +}' + output: '{ + "authStatus": false +}' + + Esignet_KycBioAuth_uin_Null_PartnerId_Neg: + endPoint: /v1/identity/createAuthRequest?id=$ID:AddIdentity_KycAuth_smoke_Pos_UIN$&idType=UIN&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/KycBioAuth/KycBioAuth + outputTemplate: esignet/KycBioAuth/KycBioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$", + "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/null​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" +}' + output: '{ + "authStatus": false +}' + + Esignet_KycBioAuth_vid_Null_PartnerId_Neg: + endPoint: /v1/identity/createAuthRequest?id=$ID:Generate_Perpetual_VID_Kyc_Valid_Smoke_sid_vid$&idType=VID&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/KycBioAuth/KycBioAuth + outputTemplate: esignet/KycBioAuth/KycBioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$", + "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/null​/$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$" +}' + output: '{ + "authStatus": false +}' + + Esignet_KycBioAuth_uin_Null_ClientId_Neg: + endPoint: /v1/identity/createAuthRequest?id=$ID:AddIdentity_KycAuth_smoke_Pos_UIN$&idType=UIN&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/KycBioAuth/KycBioAuth + outputTemplate: esignet/KycBioAuth/KycBioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$", + "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/null" +}' + output: '{ + "authStatus": false +}' + + Esignet_KycBioAuth_vid_Null_ClientId_Neg: + endPoint: /v1/identity/createAuthRequest?id=$ID:Generate_Perpetual_VID_Kyc_Valid_Smoke_sid_vid$&idType=VID&isKyc=true&isInternal=false&transactionId=$TRANSACTIONID$&isNewInternalAuth=false&isPreLTS=false&signWithMisp=true&partnerName=$ID:PartnerSelfRegistration_Misp_Valid_Smoke_sid_partnerId$&keyFileNameByPartnerName=true​&Authtype=bio&moduleName=$MODULENAME$ + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/KycBioAuth/KycBioAuth + outputTemplate: esignet/KycBioAuth/KycBioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$", + "kycAuthEndPoint": "/idauthentication/v1/kyc-auth/delegated/$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​/$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​/null" +}' + output: '{ + "authStatus": false }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/KycDemoAuth/KycAuth.yml b/automationtests/src/main/resources/esignet/KycDemoAuth/KycAuth.yml deleted file mode 100644 index aad8f3eb88c..00000000000 --- a/automationtests/src/main/resources/esignet/KycDemoAuth/KycAuth.yml +++ /dev/null @@ -1,17 +0,0 @@ -KycDemoAuth: - Esignet_KycDemoAuth_all_Valid_Smoke: - endPoint: /idauthentication/v1/kyc-auth/delegated/{idpLk}​/{partnerID}​/{oidcClientId} - role: resident - restMethod: post - inputTemplate: esignet/KycDemoAuth/KycAuth - outputTemplate: esignet/KycDemoAuth/KycAuthResult - input: '{ - "idpLk": "$ID:GenerateMispLK_All_Valid_Smoke_sid_licenseKey$​", - "partnerID": "$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$", - "oidcClientId": "$ID:CreateOIDCClient_Misp_Valid_Smoke_sid_clientId$", - "signature": "$ID:KycCreateAuthReq_AuthDemoUrl_all_Valid_Smoke_sid_authSignature$", - "request": "$ID:KycCreateAuthReq_AuthDemoUrl_all_Valid_Smoke_sid_authReqBody$" -}' - output: '{ - "kycStatus": "true" -}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/KycDemoAuth/KycCreateAuthReq.yml b/automationtests/src/main/resources/esignet/KycDemoAuth/KycCreateAuthReq.yml deleted file mode 100644 index 00a52b46809..00000000000 --- a/automationtests/src/main/resources/esignet/KycDemoAuth/KycCreateAuthReq.yml +++ /dev/null @@ -1,23 +0,0 @@ -KycCreateAuthReq: - Esignet_KycCreateAuthReq_AuthDemoUrl_all_Valid_Smoke_sid: - endPoint: /v1/identity/createAuthRequest - role: resident - restMethod: post - inputTemplate: esignet/KycDemoAuth/KycCreateAuthReq - outputTemplate: esignet/KycDemoAuth/KycDemoAuthResult - input: '{ - "id": "$ID:AddIdentity_KycAuth_smoke_Pos_UIN$", - "idType": "UIN", - "isKyc": "true", - "isInternal": "false", - "transactionId": "1234567890", - "isNewInternalAuth": "false", - "isPreLTS": "false", - "signWithMisp": "true", - "partnerName": "$ID:PartnerSelfRegistration_Kyc_Valid_Smoke_sid_partnerId$​", - "Authtype": "demo", - "moduleName": "$MODULENAME$" -}' - output: '{ - -}' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml index af7d6551426..7d16e2ce9c3 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml @@ -65,6 +65,39 @@ AuthLock: } }' + Resident_AuthLock_VID_Use_Two_All: + endPoint: /resident/v1/req/auth-lock + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/AuthLock/createAuthLock + outputTemplate: resident/AuthLock/createAuthLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authlock", + "version": "v1", + "authType": [{auth: "bio-Iris"},{auth: "demo"},{auth: "bio-FACE"}], + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + Resident_AuthLock_Valid_UIN_smoke_demo_Pos: endPoint: /resident/v1/req/auth-lock role: resident diff --git a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml index 8b99ae096b9..77b614eb164 100644 --- a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml @@ -67,6 +67,39 @@ AuthUnlock: } }' + Resident_AuthUnLock_VID_Use_Three_Pos: + endPoint: /resident/v1/req/auth-unlock + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/AuthUnLock/createAuthUnLock + outputTemplate: resident/AuthUnLock/createAuthUnLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "unlockForSeconds": "1", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authunlock", + "version": "v1", + "authType": [{auth: "bio-Iris"},{auth: "demo"},{auth: "bio-FACE"}], + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' Resident_AuthUnLock_UIN_All_Invalid_Unlock_Seconds: endPoint: /resident/v1/req/auth-unlock role: resident diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml index 89cea0587ea..cc731828d33 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -1482,4 +1482,180 @@ RequestCredentials: ], "sendOtpResTemplate":"resident/error" } -}' \ No newline at end of file +}' + Resident_RequestCredentials_euin_VID_All_Valid_Smoke_sid: + endPoint: /resident/v1/req/credential + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential + outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", + "credentialType": "euin", + "encrypt": "true", + "version": "v1", + "encryptionKey": "abc123", + "requestTime": "$TIMESTAMP$", + "otp": "$ID:AddIdentity_ValidParam_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_RequestCredentials_euin_TempVid_Smoke_sid: + endPoint: /resident/v1/req/credential + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential + outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Temporary_VID_ONE_Valid_Smoke_sid_vid$", + "credentialType": "euin", + "encrypt": "true", + "version": "v1", + "encryptionKey": "abc123", + "requestTime": "$TIMESTAMP$", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Temporary_VID_ONE_Valid_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_RequestCredentials_euin_TempVid_TwoTimes_Neg: + endPoint: /resident/v1/req/credential + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential + outputTemplate: resident/error + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Temporary_VID_ONE_Valid_Smoke_sid_vid$", + "credentialType": "euin", + "encrypt": "true", + "version": "v1", + "encryptionKey": "abc123", + "requestTime": "$TIMESTAMP$", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Temporary_VID_ONE_Valid_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + + "sendOtpResp":{ + "maskedMobile": "$IGNORE$", + "sendOtpResTemplate":"$IGNORE$", + "maskedEmail": "$IGNORE$" + }, + "errors": [ + { + "errorCode": "IDA-MLC-018" + } + ], +}' + + + Resident_RequestCredentials_euin_VID_CheckVidIs_REVOKED_Neg: + endPoint: /resident/v1/req/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential + outputTemplate: resident/error + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_Valid_First_Smoke_sid_vid$", + "credentialType": "euin", + "encrypt": "true", + "version": "v1", + "encryptionKey": "abc123", + "requestTime": "$TIMESTAMP$", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Valid_First_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "errors": [ + { + "errorCode": "IDA-MLC-023" + } + ], + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_RequestCredentials_euin_VID_Use_One_sid: + endPoint: /resident/v1/req/credential + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential + outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "credentialType": "euin", + "encrypt": "true", + "version": "v1", + "encryptionKey": "abc123", + "requestTime": "$TIMESTAMP$", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index 4d8f42729a8..dd70f501495 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -2846,7 +2846,7 @@ GenerateVID: checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GenerateVID/createGenerateVID - outputTemplate: resident/GenerateVID/createGenerateVIDResult + outputTemplate: resident/error input: '{ "transactionID": "$TRANSACTIONID$", "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_VID_Six_smoke_Pos_UIN$", @@ -2867,10 +2867,18 @@ GenerateVID: }' output: '{ "sendOtpResp":{ - "maskedMobile": "XXXXXX3210", - "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedMobile": "$IGNORE$", + "sendOtpResTemplate":"$IGNORE$", "maskedEmail": "$IGNORE$" + }, + + "errors": [ + { + "errorCode": "RES-SER-405" } + ] + + }' Resident_Generate_Perpetual_VID_Valid_First_Smoke_sid: diff --git a/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml b/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml index 16b16821aca..0659e54e85f 100644 --- a/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml +++ b/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml @@ -32,6 +32,25 @@ SendOTP: "maskedMobile": "XXXXXX3210", "maskedEmail": "$IGNORE$" }' + + + Resident_SendOTP_Valid_VID_Use_Five_Smoke: + endPoint: /resident/v1/req/otp + role: resident + restMethod: post + inputTemplate: resident/SendOTP/createSendOTP + outputTemplate: resident/SendOTP/createSendOTPResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "UIN" +}' + output: '{ + "maskedMobile": "XXXXXX3210", + "maskedEmail": "$IGNORE$" + }' + Resident_SendOTP_Valid_UIN_Phone_Smoke: endPoint: /resident/v1/req/otp role: resident From a0d7f137e08f7dfbaaa97bada1f3e4e234bf86d6 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 27 Sep 2023 21:05:28 +0530 Subject: [PATCH 188/204] MOSIP-29513 --- .../apirig/admin/fw/util/AdminTestUtil.java | 4 + .../AuthenticateUserVCI.yml | 99 +++++++++++ .../AuthorizationCodeVCI.yml | 66 +++++++ .../VCINegTC/GetCredential/GetCredential.yml | 42 +++++ .../OAuthDetailsRequestVCI.yml | 168 ++++++++++++++++++ 5 files changed, 379 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 70533b94740..0686dd5ed6f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3278,6 +3278,10 @@ else if (testCaseName.contains("_Invalid_JwkHeader_")) jwkHeader = RSAKey.parse(getJWKKey(oidcJWK2)).toPublicJWK(); else if (testCaseName.contains("_Invalid_Aud_")) tempUrl = "sdfaf"; + else if (testCaseName.contains("_Empty_Aud_")) + tempUrl = ""; + else if (testCaseName.contains("_SpaceVal_Aud_")) + tempUrl = " "; else if (testCaseName.contains("_Invalid_Iss_")) clientId = "sdfdsg"; else if (testCaseName.contains("_Invalid_Exp_")) diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml index bb5467cfc8d..0134d100acd 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -591,4 +591,103 @@ AuthenticateUserVCINegTC: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen5_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen6_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_uin_Otp_NegAuthCodeScen7_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCINegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_Inv_Scen_smoke_Pos_UIN$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index 7818765b030..55dc0da35b0 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -315,4 +315,70 @@ AuthorizationCodeVCINegTC: "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegCredScen9_Valid_Smoke_sid_transactionId$" }' output: '{ +}' + + ESignet_AuthorizationCode_VCI_uin_SpaceVal_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: " "}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_Empty_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: ""}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] +}' + + ESignet_AuthorizationCode_VCI_uin_spaceVal_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: " "}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml index a6b39199d78..f7face0ffd2 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/GetCredential/GetCredential.yml @@ -750,6 +750,48 @@ GetCredentialNegTC: "error":"invalid_proof" }' + ESignet_GetCredential_uin_IdpAccessToken_Empty_Aud_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + + ESignet_GetCredential_uin_IdpAccessToken_SpaceVal_Aud_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCINegTC/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_uin_NegCredScen9_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"invalid_proof" +}' + ESignet_GetCredential_uin_IdpAccessToken_Invalid_Iss_Neg: endPoint: /v1/esignet/vci/credential role: resident diff --git a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index dd5d549aac4..83124641676 100644 --- a/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -29,6 +29,36 @@ OAuthDetailsRequestVCINegTC: ] }' + ESignet_OAuthDetailsRequest_VCI_uin_SpaceVal_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": " ", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + ESignet_OAuthDetailsRequest_VCI_uin_Diff_Scope_sid: endPoint: /v1/esignet/authorization/v2/oauth-details role: resident @@ -145,6 +175,36 @@ OAuthDetailsRequestVCINegTC: ] }' + ESignet_OAuthDetailsRequest_VCI_uin_SpaceVal_Code_Challenge_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": " ", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_pkce_challenge" + } + ] +}' + ESignet_OAuthDetailsRequest_VCI_uin_Empty_Code_Challenge_Method_Neg: endPoint: /v1/esignet/authorization/v2/oauth-details role: resident @@ -175,6 +235,36 @@ OAuthDetailsRequestVCINegTC: ] }' + ESignet_OAuthDetailsRequest_VCI_uin_SpaceVal_Code_Challenge_Method_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": " " +}' + output: '{ + "errors": [ + { + "errorCode": "unsupported_pkce_challenge_method" + } + ] +}' + ESignet_OAuthDetailsRequest_VCI_uin_Long_Code_Challenge_Pos: endPoint: /v1/esignet/authorization/v2/oauth-details role: resident @@ -381,6 +471,84 @@ OAuthDetailsRequestVCINegTC: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen5_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen6_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_uin_NegAuthCodeScen7_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCINegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' ESignet_OAuthDetailsRequest_VCI_uin_NegTokenScen1_Valid_Smoke_sid: From 39aca0047b5a47f687ec767cd9bc62fc440f3520 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Thu, 28 Sep 2023 11:54:42 +0530 Subject: [PATCH 189/204] MOSIP-29444 --- .../resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml | 4 ++-- .../src/main/resources/partner/policy/Search/SearchPolicy.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml index 07f1045e567..edbb3ba011b 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml @@ -12,8 +12,8 @@ GetPartnersPolicy: "requesttime": "$TIMESTAMP$" }' output: '{ - "policyGroupId": "mpolicygroup-default-auth", - "policyGroupName": "mpolicygroup-default-auth", + "policyGroupId": "521893", + "policyGroupName": "auth_module", "policyId": "$IGNORE$", "policyName": "$IGNORE$", "status": "PUBLISHED" diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index 67ef3fedb43..d92711efe07 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -89,7 +89,7 @@ createSearchPolicy: output: '{ "data": [ { - "policyType": "Datashare", + "policyType": "DataShare", "schema": "$IGNORE$" } ] From 307b7170e933e0ba01bbe2eb63c780bc459da971 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 28 Sep 2023 21:43:01 +0530 Subject: [PATCH 190/204] MOSIP-29286 --- .../main/resources/config/Kernel.properties | 8 +- .../resources/ida/AddIdentity/AddIdentity.yml | 83 ++++++++++++++++++- .../resources/ida/AuthLock/createAuthLock.yml | 62 ++++++++++++++ .../ida/AuthUnLock/createAuthUnLock.yml | 33 ++++++++ .../main/resources/ida/BioAuth/BioAuth.yml | 30 ++++++- .../main/resources/ida/DemoAuth/DemoAuth.yml | 33 +++++++- .../main/resources/ida/EkycBio/EkycBio.yml | 2 +- .../main/resources/ida/EkycOtp/EkycOtp.yml | 2 +- .../main/resources/ida/OtpAuth/OtpAuth.yml | 40 ++++++++- .../ida/OtpAuth/OtpAuthHotlisted.yml | 39 +++++++++ .../ida/OtpAuth/OtpAuthHotlistedUnblocked.yml | 39 +++++++++ .../testNgXmlFiles/authenticationApi.xml | 15 ++++ 12 files changed, 376 insertions(+), 10 deletions(-) create mode 100644 automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlisted.yml create mode 100644 automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlistedUnblocked.yml diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 8f6bdaee3c5..12ce158754f 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -#authDemoServiceBaseURL=http://localhost -#authDemoServicePort=8082 +authDemoServiceBaseURL=http://localhost +authDemoServicePort=8082 #To run in Docker -authDemoServiceBaseURL=http://authdemo.apitestrig -authDemoServicePort=80 +#authDemoServiceBaseURL=http://authdemo.apitestrig +#authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# diff --git a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml index 2565c0ed782..3247bb73cb9 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml @@ -40,7 +40,35 @@ AddIdentity: "addressCopy": "Y", "biometricReferenceId": "23452353", "UIN": "$UIN$", - "dateOfBirth": "2023/09/09", + "dateOfBirth": "2023/09/28", + "postalCode": "14022", + "email": "auth_AddIdentity_withValidParameters_smoke_Pos@mosip.net", + "phone": "7019858531", + "mobileno": "7019858531", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + auth_AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: ida/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: ida/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "2023/09/28", "postalCode": "14022", "email": "auth_AddIdentity_withValidParameters_smoke_Pos@mosip.net", "phone": "7019858531", @@ -937,4 +965,57 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + auth_AddIdentity_no_email_no_phone_sid_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + regenerateHbs: true + restMethod: post + inputTemplate: ida/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: ida/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1970/07/08", + "postalCode": "14022", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + auth_AddIdentity_withValidParameters_smoke_Pos_without_Email: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: ida/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: ida/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1970/07/08", + "postalCode": "14022", + "phone": "7019858531", + "mobileno": "7019858531", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml index 2fae8d61174..8e3b9822273 100644 --- a/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml @@ -29,6 +29,37 @@ AuthLock: "maskedMobile": "XXXXXX8531", "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" } +}' + auth_AuthLock_Valid_child_UIN_which_locked: + endPoint: /resident/v1/req/auth-lock + role: resident + restMethod: post + inputTemplate: ida/AuthLock/createAuthLock + outputTemplate: ida/AuthLock/createAuthLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authlock", + "version": "v1", + "authType": [{auth: "demo"}], + "otp": "$ID:AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "ida/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "message": "Notification has been sent to the provided contact detail(s)", + "sendOtpResp":{ + "maskedMobile": "XXXXXX8531", + "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" + } }' auth_AuthLock_Valid_UIN_for_bio_auth: endPoint: /resident/v1/req/auth-lock @@ -60,4 +91,35 @@ AuthLock: "maskedMobile": "XXXXXX8531", "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" } +}' + auth_AuthLock_Valid_UIN_without_phon_email_uin: + endPoint: /resident/v1/req/auth-lock + role: resident + restMethod: post + inputTemplate: ida/AuthLock/createAuthLock + outputTemplate: ida/AuthLock/createAuthLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_no_email_no_phone_sid_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authlock", + "version": "v1", + "authType": [{auth: "bio-Finger"}], + "otp": "$ID:AddIdentity_no_email_no_phone_sid_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_no_email_no_phone_sid_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "ida/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "message": "Notification has been sent to the provided contact detail(s)", + "sendOtpResp":{ + "maskedMobile": "XXXXXX8531", + "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLock.yml index cc23a298669..e03f91f3ffa 100644 --- a/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/ida/AuthUnLock/createAuthUnLock.yml @@ -64,4 +64,37 @@ AuthUnlock: "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult", "maskedEmail": "$IGNORE$" } +}' + auth_AuthUnLock_Valid_UIN_DEMO_UNLOCK_without_phon_email_uin: + endPoint: /resident/v1/req/auth-unlock + role: resident + restMethod: post + inputTemplate: ida/AuthUnLock/createAuthUnLock + outputTemplate: ida/AuthUnLock/createAuthUnLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_no_email_no_phone_sid_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authunlock", + "version": "v1", + "authType": [{auth: "demo"},{auth: "bio-FACE"}], + "otp": "$ID:AddIdentity_no_email_no_phone_sid_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_no_email_no_phone_sid_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "ida/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "registrationId": "$IGNORE$", + "message": "Notification has been sent to the provided contact detail(s)", + "sendOtpResp":{ + "maskedMobile": "XXXXXX8531", + "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml index 108b44db2fe..ae2da0be326 100644 --- a/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml +++ b/automationtests/src/main/resources/ida/BioAuth/BioAuth.yml @@ -53,7 +53,35 @@ BioAuth: "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": "true" + "authStatus": "false" +}' + auth_BioAuth_Biometric_Face_With_Infant_locked_uin_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuth/BioAuth + outputTemplate: ida/BioAuth/BioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false" }' auth_BioAuth_Biometric_RingFinger_With_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index 318d5d4af3a..a114bee6150 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -58,6 +58,21 @@ DemoAuthNew: }' output: '{ "authStatus": "true" +}' + auth_DemoAuth_DOB_Valid_Smoke_VID_invalid_transaction_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoAuth + outputTemplate: ida/DemoAuth/DemoAuthResult + input: '{ + "timestamp": "$TIMESTAMP$", + "transactionId": "1254@#45gg", + "value": "1970/07/08", + "key": "dob" + }' + output: '{ + "authStatus": "false" }' auth_DemoAuth_DOB_Valid_Smoke_Infant_Uin_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_Infant_smoke_Pos_UIN$&idType=UIN&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ @@ -68,13 +83,29 @@ DemoAuthNew: input: '{ "timestamp": "$TIMESTAMP$", "transactionId": "$TRANSACTIONID$", - "value": "1970/07/08", + "value": "2023/09/28", "key": "dob" }' output: '{ "authStatus": "true" }' + auth_DemoAuth_DOB_Valid_Smoke_Infant_Uin_which_locked_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos_UIN$&idType=UIN&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoAuth + outputTemplate: ida/DemoAuth/DemoAuthResult + input: '{ + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$", + "value": "2023/09/28", + "key": "dob" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuth_DOB_Invalid_Past_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2022-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident diff --git a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml index 919d3393603..2eb6e56ac02 100644 --- a/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml +++ b/automationtests/src/main/resources/ida/EkycBio/EkycBio.yml @@ -53,7 +53,7 @@ EkycBio: "timestamp": "$TIMESTAMP$" }' output: '{ - "kycStatus": "true" + "kycStatus": "false" }' auth_EkycBio_Face_With_draft_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GetDraft_all_valid_smoke_sid_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ diff --git a/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml b/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml index 0333768e468..ed3b347861c 100644 --- a/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml +++ b/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml @@ -35,7 +35,7 @@ EkycOtp: "timestamp": "$TIMESTAMP$" }' output: '{ - "kycStatus": "true", + "kycStatus": "false", "sendOtpResp":{ "transactionID": "$IGNORE$", "maskedMobile": "$IGNORE$", diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml index ca522ac5216..0b34eb3b914 100644 --- a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml @@ -33,7 +33,26 @@ OtpAuth: "timestamp": "$TIMESTAMP$" }' output: '{ - "authStatus": "true", + "authStatus": "false", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + } +}' + auth_OTP_Auth_With_Infant_locked_UIN_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_with_Infant_which_locked_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/OtpAuth/OtpAuth + outputTemplate: ida/OtpAuth/OtpAuthResult + input: '{ + "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false", "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } @@ -520,4 +539,23 @@ OtpAuth: "sendOtpResp":{ "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" } +}' + auth_OTP_Auth_With_Uin_withou_Email_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_without_Email_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/OtpAuth/OtpAuth + outputTemplate: ida/OtpAuth/OtpAuthResult + input: '{ + "otp": "$ID:AddIdentity_withValidParameters_smoke_Pos_without_Email_EMAIL$", + "individualId": "$ID:AddIdentity_withValidParameters_smoke_Pos_without_Email_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlisted.yml b/automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlisted.yml new file mode 100644 index 00000000000..c20ac4f3d8a --- /dev/null +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlisted.yml @@ -0,0 +1,39 @@ +OtpAuth: + auth_OTP_Auth_With_blocked_partnerid_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/OtpAuth/OtpAuth + outputTemplate: ida/OtpAuth/OtpAuthResult + input: '{ + "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + } +}' + auth_OTP_Auth_With_blocked_misp_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/OtpAuth/OtpAuth + outputTemplate: ida/OtpAuth/OtpAuthResult + input: '{ + "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + } +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlistedUnblocked.yml b/automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlistedUnblocked.yml new file mode 100644 index 00000000000..c20ac4f3d8a --- /dev/null +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuthHotlistedUnblocked.yml @@ -0,0 +1,39 @@ +OtpAuth: + auth_OTP_Auth_With_blocked_partnerid_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/OtpAuth/OtpAuth + outputTemplate: ida/OtpAuth/OtpAuthResult + input: '{ + "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + } +}' + auth_OTP_Auth_With_blocked_misp_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: ida/OtpAuth/OtpAuth + outputTemplate: ida/OtpAuth/OtpAuthResult + input: '{ + "otp": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_EMAIL$", + "individualId": "$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$", + "transactionID": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "false", + "sendOtpResp":{ + "sendOtpResTemplate":"ida/OtpAuth/sendOtpRes" + } +}' \ No newline at end of file diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index 323f8091b99..a4430075eb3 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -263,6 +263,13 @@ + + + + + + + + + + + + + + + From a55ea2d756f59925bf947307f7be746e2f597a0a Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Fri, 29 Sep 2023 08:25:56 +0530 Subject: [PATCH 191/204] MOSIP-29631 --- .../resident/AddIdentity/AddIdentity.yml | 116 ++++++++++++ .../resident/AuthLock/createAuthLock.yml | 33 ++++ .../resident/AuthUnLock/createAuthUnLock.yml | 34 ++++ .../RequestCredentials/ReqCredential.yml | 33 ++++ .../GenerateVID/createGenerateVID.yml | 168 ++++++++++++++++++ .../resources/resident/SendOTP/SendOTP.yml | 54 ++++++ 6 files changed, 438 insertions(+) diff --git a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml index dbff54d3968..4be1dba6b28 100644 --- a/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/resident/AddIdentity/AddIdentity.yml @@ -722,4 +722,120 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + + Resident_AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "Resident_AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + + Resident_AddIdentity_withValidParameters_To_Genrate_TempVid_Use_3_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "Resident_AddIdentity_withValidParameters_To_Genrate_TempVid_Use_3_smoke_Pos@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + + Resident_AddIdentity_withValidParameters_For_SendOtp_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "Resident_AddIdentity_withValidParameters_For_SendOtp_smoke_Pos@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + + Resident_AddIdentity_withValidParameters_To_Check_Ten_Transactions_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: resident/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: resident/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "Resident_AddIdentity_withValidParameters_For_SendOtp_smoke_Pos@mosip.net", + "phone": "9876543210", + "mobileno": "9876543210", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml index 7d16e2ce9c3..db21bc743b3 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml @@ -98,6 +98,39 @@ AuthLock: } }' + Resident_AuthLock_VID_Use_All: + endPoint: /resident/v1/req/auth-lock + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/AuthLock/createAuthLock + outputTemplate: resident/AuthLock/createAuthLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authlock", + "version": "v1", + "authType": [{auth: "bio-Iris"},{auth: "demo"},{auth: "bio-FACE"}], + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + Resident_AuthLock_Valid_UIN_smoke_demo_Pos: endPoint: /resident/v1/req/auth-lock role: resident diff --git a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml index 77b614eb164..0e22a00e364 100644 --- a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml @@ -100,6 +100,40 @@ AuthUnlock: "maskedEmail": "$IGNORE$" } }' + + Resident_AuthUnLock_VID_Use_Pos: + endPoint: /resident/v1/req/auth-unlock + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/AuthUnLock/createAuthUnLock + outputTemplate: resident/AuthUnLock/createAuthUnLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "unlockForSeconds": "1", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authunlock", + "version": "v1", + "authType": [{auth: "bio-Iris"},{auth: "demo"},{auth: "bio-FACE"}], + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' Resident_AuthUnLock_UIN_All_Invalid_Unlock_Seconds: endPoint: /resident/v1/req/auth-unlock role: resident diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml index cc731828d33..8f9f4806807 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -1659,3 +1659,36 @@ RequestCredentials: "maskedEmail": "$IGNORE$" } }' + + Resident_RequestCredentials_euin_VID_Use_sid: + endPoint: /resident/v1/req/credential + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential + outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "credentialType": "euin", + "encrypt": "true", + "version": "v1", + "encryptionKey": "abc123", + "requestTime": "$TIMESTAMP$", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "VID", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index dd70f501495..6b89d2ea71e 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -2948,4 +2948,172 @@ GenerateVID: "maskedEmail": "$IGNORE$" } +}' + + Resident_Generate_Perpetual_VID_1_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } + +}' + + Resident_Generate_Perpetual_VID_2_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } + +}' + + Resident_Generate_Perpetual_VID_3_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_ToCreate_Three_PreVid_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } + +}' + + Resident_Generate_Temporary_VID_use_3_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_TempVid_Use_3_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Temporary", + "otp": "$ID:AddIdentity_withValidParameters_To_Genrate_TempVid_Use_3_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_To_Genrate_TempVid_Use_3_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } +}' + + Resident_Generate_Perpetual_VID_For_SendOtp_Valid_Smoke_sid: + endPoint: /resident/v1/vid + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: resident/GenerateVID/createGenerateVID + outputTemplate: resident/GenerateVID/createGenerateVIDResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_withValidParameters_For_SendOtp_smoke_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.vid", + "version": "v1", + "vidType": "Perpetual", + "otp": "$ID:AddIdentity_withValidParameters_For_SendOtp_smoke_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_withValidParameters_For_SendOtp_smoke_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "resident/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"resident/SendOTP/createSendOTPResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml b/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml index 0659e54e85f..2d5c47b5a5c 100644 --- a/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml +++ b/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml @@ -51,6 +51,23 @@ SendOTP: "maskedEmail": "$IGNORE$" }' + Resident_SendOTP_Valid_VID_Use_Smoke: + endPoint: /resident/v1/req/otp + role: resident + restMethod: post + inputTemplate: resident/SendOTP/createSendOTP + outputTemplate: resident/SendOTP/createSendOTPResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_SecondTime_Smoke_sid_vid$", + "individualIdType": "UIN" +}' + output: '{ + "maskedMobile": "XXXXXX3210", + "maskedEmail": "$IGNORE$" + }' + Resident_SendOTP_Valid_UIN_Phone_Smoke: endPoint: /resident/v1/req/otp role: resident @@ -263,4 +280,41 @@ SendOTP: output: '{ "maskedMobile": "XXXXXX3210", "maskedEmail": "$IGNORE$" + }' + + Resident_SendOTP_Valid_VID_Phone_Smoke: + endPoint: /resident/v1/req/otp + role: resident + restMethod: post + inputTemplate: resident/SendOTP/createSendOTPAsPhone + outputTemplate: resident/SendOTP/createSendOTPResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "otpChannel": "[\"PHONE\"]", + "individualId": "$ID:Generate_Perpetual_VID_For_SendOtp_Valid_Smoke_sid_vid$", + "individualIdType": "VID" +}' + output: '{ + "maskedMobile": "XXXXXX3210", + "maskedEmail": "$IGNORE$" + }' + + Resident_SendOTP_Valid_Vid_Email_Smoke: + endPoint: /resident/v1/req/otp + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + inputTemplate: resident/SendOTP/createSendOTPAsEmail + outputTemplate: resident/SendOTP/createSendOTPResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "otpChannel": "[\"EMAIL\"]", + "individualId": "$ID:Generate_Perpetual_VID_For_SendOtp_Valid_Smoke_sid_vid$", + "individualIdType": "VID" +}' + output: '{ + "maskedMobile": "$IGNORE$", + "maskedEmail": "$IGNORE$" }' \ No newline at end of file From 33a30d376304491f088cb0d9b3810e40652d793e Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 29 Sep 2023 18:01:42 +0530 Subject: [PATCH 192/204] ES-297 --- .../apirig/admin/fw/util/AdminTestUtil.java | 102 ++++++++++++++++++ .../LinkedAuthorizationConsent.yml | 28 ++++- .../LinkAuthorizationConsent.hbs | 19 ++++ .../LinkAuthorizationConsent.yml | 10 +- 4 files changed, 153 insertions(+), 6 deletions(-) create mode 100644 automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 0686dd5ed6f..3aebbbc2e2c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -3167,22 +3167,42 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENT$", generateWLAToken(jsonString, bindingConsentJWK, bindingCertConsentFile)); } + + if (jsonString.contains("$CONSENTDETACHEDSIGNATURE$")) { + jsonString = replaceKeywordWithValue(jsonString, "$CONSENTDETACHEDSIGNATURE$", + generateDetachedSignature(jsonString, bindingConsentJWK, bindingCertConsentFile)); + } if (jsonString.contains("$WLATOKENCONSENTVID$")) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTVID$", generateWLAToken(jsonString, bindingConsentJWKVid, bindingCertConsentVidFile)); } + + if (jsonString.contains("$CONSENTDETACHEDSIGNATUREVID$")) { + jsonString = replaceKeywordWithValue(jsonString, "$CONSENTDETACHEDSIGNATUREVID$", + generateDetachedSignature(jsonString, bindingConsentJWKVid, bindingCertConsentVidFile)); + } if (jsonString.contains("$WLATOKENCONSENTSAMECLAIM$")) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTSAMECLAIM$", generateWLAToken(jsonString, bindingConsentSameClaimJWK, bindingCertConsentSameClaimFile)); } + + if (jsonString.contains("$CONSENTDETACHEDSIGNATURESAMECLAIM$")) { + jsonString = replaceKeywordWithValue(jsonString, "$CONSENTDETACHEDSIGNATURESAMECLAIM$", + generateDetachedSignature(jsonString, bindingConsentSameClaimJWK, bindingCertConsentSameClaimFile)); + } if (jsonString.contains("$WLATOKENCONSENTVIDSAMECLAIM$")) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTVIDSAMECLAIM$", generateWLAToken(jsonString, bindingConsentVidSameClaimJWK, bindingCertConsentVidSameClaimFile)); } + if (jsonString.contains("$CONSENTDETACHEDSIGNATUREVIDSAMECLAIM$")) { + jsonString = replaceKeywordWithValue(jsonString, "$CONSENTDETACHEDSIGNATUREVIDSAMECLAIM$", + generateDetachedSignature(jsonString, bindingConsentVidSameClaimJWK, bindingCertConsentVidSameClaimFile)); + } + if (jsonString.contains("$WLATOKENCONSENTEMPTYCLAIM$")) { jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTEMPTYCLAIM$", generateWLAToken(jsonString, bindingConsentEmptyClaimJWK, bindingCertConsentEmptyClaimFile)); @@ -3330,6 +3350,88 @@ public static String generateWLAToken(String jsonString, File jwkfileName, File return wlaToken; } + + public static String generateDetachedSignature(String jsonString, File jwkfileName, File certFileName) { + RSAKey jwkKey = null; + String jwkKeyString = getJWKKey(jwkfileName); + logger.info("jwkKeyString =" + jwkKeyString); + + String[] acceptedClaims = null; + JSONArray claimJsonArray = null; + String[] permittedScope = null; + JSONArray permittedScopeArray = null; + String detachedSignature = ""; + String certificate = getJWKKey(certFileName); + JSONObject request = new JSONObject(jsonString); + claimJsonArray = getArrayFromJson(request, "acceptedClaims"); + permittedScopeArray = getArrayFromJson(request, "permittedAuthorizeScopes"); + + acceptedClaims = new String[claimJsonArray.length()]; + permittedScope = new String[permittedScopeArray.length()]; + + for (int i = 0; i < claimJsonArray.length(); i++) { + acceptedClaims[i] = claimJsonArray.getString(i); + } + if (acceptedClaims != null && acceptedClaims instanceof String[]) { + Arrays.sort(acceptedClaims); + } + + for (int i = 0; i < permittedScopeArray.length(); i++) { + permittedScope[i] = permittedScopeArray.getString(i); + } + + + try { + jwkKey = RSAKey.parse(jwkKeyString); + logger.info("jwkKey =" + jwkKey); + detachedSignature = getDetachedSignature(acceptedClaims, permittedScope, jwkKey, certificate); + } catch (Exception e) { + logger.error(e.getMessage()); + } + + return detachedSignature; + + } + + public static String getDetachedSignature(String[] acceptedClaims, String[] permittedScope, RSAKey jwkKey, String certData) + throws JoseException, JOSEException { + JSONObject payload = new JSONObject(); + String signedJWT = null; + + if (acceptedClaims != null && acceptedClaims instanceof String[]) { + Arrays.sort(acceptedClaims); + payload.put("accepted_claims", acceptedClaims); + } + + if (permittedScope != null && permittedScope instanceof String[]) { + Arrays.sort(permittedScope); + payload.put("permitted_authorized_scopes", permittedScope); + } + + X509Certificate certificate = (X509Certificate) convertToCertificate(certData); + JsonWebSignature jwSign = new JsonWebSignature(); + if (certificate != null) { + jwSign.setX509CertSha256ThumbprintHeaderValue(certificate); + jwSign.setPayload(payload.toString()); + jwSign.setAlgorithmHeaderValue(SIGN_ALGO); + jwSign.setKey(jwkKey.toPrivateKey()); + jwSign.setDoKeyValidation(false); + signedJWT = jwSign.getCompactSerialization(); + String[] parts = signedJWT.split("\\."); + + return parts[0] + "." + parts[2]; + } + return ""; + } + + public static JSONArray getArrayFromJson(JSONObject request, String value) { + + if (request.getJSONObject(GlobalConstants.REQUEST).has(value)) { + return request.getJSONObject(GlobalConstants.REQUEST).getJSONArray(value); + } + + return null; + } public static String generateAndWriteJWKKey(File fileName) { String jwkKey = MosipTestRunner.generateJWKPublicKey(); diff --git a/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml b/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml index c588234f00b..6024fb1020f 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent.yml @@ -5,12 +5,36 @@ LinkedAuthorizationConsent: checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true - inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent + inputTemplate: esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent outputTemplate: esignet/error input: '{ "requestTime": "$TIMESTAMP$", "linkedTransactionId": "$ID:LinkTransaction_Consent_uin_SameClaim_all_Valid_Smoke_sid_linkTransactionId$", - "acceptedClaims": [{claim: "name"},{claim: "gender"},{claim: "email"}] + "acceptedClaims": [{claim: "name"},{claim: "email"}], + "signature": "$CONSENTDETACHEDSIGNATURESAMECLAIM$" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_transaction", + "errorMessage": "$IGNORE$" + } + ] +}' + + ESignet_LinkedAuthorizationConsent_Consent_Vid_SameClaim_Invalid_Neg: + endPoint: /v1/esignet/linked-authorization/v2/consent + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "linkedTransactionId": "$ID:LinkTransaction_Consent_Vid_SameClaim_all_Valid_Smoke_sid_linkTransactionId$", + "acceptedClaims": [{claim: "name"},{claim: "gender"},{claim: "email"}], + "signature": "$CONSENTDETACHEDSIGNATUREVIDSAMECLAIM$" }' output: '{ "errors": [ diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.hbs b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.hbs new file mode 100644 index 00000000000..5566900f49e --- /dev/null +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.hbs @@ -0,0 +1,19 @@ +{ + "requestTime": "{{requestTime}}", + "request": { + "linkedTransactionId": "{{linkedTransactionId}}", + "permittedAuthorizeScopes": [ + {{#each permittedAuthorizeScopes}} + "{{scope}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "acceptedClaims": [ + {{#each acceptedClaims}} + "{{claim}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "signature": "{{signature}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml index 17679402a2a..e764c436f1a 100644 --- a/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml +++ b/automationtests/src/main/resources/esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent.yml @@ -5,12 +5,13 @@ LinkAuthorizationConsent: checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true - inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent + inputTemplate: esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent outputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult input: '{ "requestTime": "$TIMESTAMP$", "linkedTransactionId": "$ID:LinkTransaction_Consent_uin_all_Valid_Smoke_sid_linkTransactionId$", - "acceptedClaims": [{claim: "name"},{claim: "gender"},{claim: "email"}] + "acceptedClaims": [{claim: "name"},{claim: "gender"},{claim: "email"}], + "signature": "$CONSENTDETACHEDSIGNATURE$" }' output: '{ @@ -22,12 +23,13 @@ LinkAuthorizationConsent: checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true - inputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsent + inputTemplate: esignet/LinkedConsent/LinkAuthorizationConsent/LinkAuthorizationConsent outputTemplate: esignet/LinkedAuthorizationConsent/LinkedAuthorizationConsentResult input: '{ "requestTime": "$TIMESTAMP$", "linkedTransactionId": "$ID:LinkTransaction_Consent_Vid_all_Valid_Smoke_sid_linkTransactionId$", - "acceptedClaims": [{claim: "name"},{claim: "gender"},{claim: "email"}] + "acceptedClaims": [{claim: "name"},{claim: "gender"},{claim: "email"}], + "signature": "$CONSENTDETACHEDSIGNATUREVID$" }' output: '{ From 0ef5e423527112a93b2d9e1c16612782732937ba Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 29 Sep 2023 18:05:15 +0530 Subject: [PATCH 193/204] resolve conflicts --- .../src/main/resources/config/Kernel.properties | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 12ce158754f..8f6bdaee3c5 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -authDemoServiceBaseURL=http://localhost -authDemoServicePort=8082 +#authDemoServiceBaseURL=http://localhost +#authDemoServicePort=8082 #To run in Docker -#authDemoServiceBaseURL=http://authdemo.apitestrig -#authDemoServicePort=80 +authDemoServiceBaseURL=http://authdemo.apitestrig +authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# From bd584e946067e14f4f725f2a6623003008ea6ad8 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 3 Oct 2023 20:00:08 +0530 Subject: [PATCH 194/204] MOSIP-29513 --- .../esignet/GenerateVID/createGenerateVID.yml | 6 +- .../esignet/SendBindingOtp/SendBindingOtp.yml | 2 + .../AuthenticateUserVCI.yml | 66 +++++++++++++++++++ .../AuthorizationCodeVCI.yml | 32 +++++++++ .../GenerateTokenVCI/GenerateTokenVCI.yml | 40 +++++++++++ .../VCIVid/GetCredential/GetCredential.yml | 61 +++++++++++++++++ .../OAuthDetailsRequestVCI.yml | 52 +++++++++++++++ 7 files changed, 256 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml index 07c2d8abfb3..8f84cb0c481 100644 --- a/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/esignet/GenerateVID/createGenerateVID.yml @@ -449,17 +449,17 @@ GenerateVID: outputTemplate: esignet/GenerateVID/createGenerateVIDResult input: '{ "transactionID": "$TRANSACTIONID$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", "individualIdType": "UIN", "requesttime": "$TIMESTAMP$", "id": "mosip.resident.vid", "version": "v1", "vidType": "Perpetual", - "otp": "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_EMAIL$", + "otp": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_EMAIL$", "sendOtp":{ "transactionID": "$TRANSACTIONID$", "requestTime": "$TIMESTAMP$", - "individualId": "$ID:AddIdentity_Valid_Params_VCI_Vid_smoke_Pos_UIN$", + "individualId": "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_UIN$", "individualIdType": "UIN", "sendOtpReqTemplate": "esignet/SendOTPRes/createSendOTP", "sendOtpEndPoint": "/resident/v1/req/otp" diff --git a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml index 4587f4aed58..a585f00fa90 100644 --- a/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml +++ b/automationtests/src/main/resources/esignet/SendBindingOtp/SendBindingOtp.yml @@ -244,6 +244,7 @@ SendBindingOtp: endPoint: /v1/esignet/binding/binding-otp role: mobileauth validityCheckRequired: true + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp outputTemplate: esignet/SendBindingOtp/SendBindingOtpResult @@ -263,6 +264,7 @@ SendBindingOtp: endPoint: /v1/esignet/binding/binding-otp role: mobileauth validityCheckRequired: true + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: esignet/SendBindingOtp/SendBindingOtp outputTemplate: esignet/SendBindingOtp/SendBindingOtpResult diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml index 8051033a6ce..85583591d0f 100644 --- a/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -30,4 +30,70 @@ AuthenticateUserVCIVid: "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", "maskedEmail": "$IGNORE$" } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_1stLang_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_2ndLang_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCI/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_uin_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml index fdc44a331b8..710ea88e18e 100644 --- a/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml +++ b/automationtests/src/main/resources/esignet/VCIVid/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -13,4 +13,36 @@ AuthorizationCodeVCIVid: "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_all_Valid_Smoke_sid_transactionId$" }' output: '{ +}' + + ESignet_AuthorizationCode_VCI_Vid_All_1stLang_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid_transactionId$" +}' + output: '{ +}' + + ESignet_AuthorizationCode_VCI_Vid_All_2ndLang_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/VCI/AuthorizationCodeVCI/AuthorizationCodeVCIResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid_transactionId$" +}' + output: '{ }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml index 7444ba4672a..b87c1eeb3ac 100644 --- a/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml +++ b/automationtests/src/main/resources/esignet/VCIVid/GenerateTokenVCI/GenerateTokenVCI.yml @@ -17,4 +17,44 @@ GenerateTokenVCIVid: }' output: '{ "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_Vid_1stLang_Valid_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_Vid_All_1stLang_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" +}' + + ESignet_GenerateTokenVCI_Vid_2ndLang_Valid_Smoke_sid: + endPoint: /v1/esignet/oauth/v2/token + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCI + outputTemplate: esignet/VCI/GenerateTokenVCI/GenerateTokenVCIResult + input: '{ + "grant_type": "authorization_code", + "code": "$ID:AuthorizationCode_VCI_Vid_All_2ndLang_Valid_Smoke_sid_code$", + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", + "client_assertion": "$CLIENT_ASSERTION_JWK$", + "redirect_uri": "$IDPREDIRECTURI$", + "code_verifier": "$CODEVERIFIER$" +}' + output: '{ + "token_type": "Bearer" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml index dd5c5399fe2..58acf115bb0 100644 --- a/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml +++ b/automationtests/src/main/resources/esignet/VCIVid/GetCredential/GetCredential.yml @@ -17,4 +17,65 @@ GetCredentialVid: "proof_jwt": "$PROOFJWT$" }' output: '{ +}' + + ESignet_GetCredential_Vid_IdpAccessToken_1stLang_all_Valid_Smoke: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/VCI/GetCredential/GetCredentialResult + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_Vid_1stLang_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ +}' + + ESignet_GetCredential_Vid_IdpAccessToken_2ndLang_all_Valid_Smoke: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/VCI/GetCredential/GetCredentialResult + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_Vid_2ndLang_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ +}' + + ESignet_GetCredential_Vid_IdpAccessToken_2ndLang_Invalid_Token_Neg: + endPoint: /v1/esignet/vci/credential + role: resident + checkErrorsOnlyInResponse: true + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/VCI/GetCredential/GetCredential + outputTemplate: esignet/error2 + input: '{ + "client_id": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "idpAccessToken": "$ID:GenerateTokenVCI_Vid_2ndLang_Valid_Smoke_sid_access_token$", + "format": "ldp_vc", + "type": [{types: "VerifiableCredential"}, {types: "MOSIPVerifiableCredential"}], + "@context": [{context: "$VCICONTEXTURL$"}], + "proof_type": "jwt", + "proof_jwt": "$PROOFJWT$" +}' + output: '{ + "error":"vci_exchange_failed" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index ecfed1081b9..d8b14dc5cf3 100644 --- a/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCIVid/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -23,4 +23,56 @@ OAuthDetailsRequestVCIVid: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_1stLang_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "$1STLANG$", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_2ndLang_all_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCI/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "$2NDLANG$", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' \ No newline at end of file From eac95016e147105b867ad7ddbe9bbbeb62261e62 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 3 Oct 2023 20:45:09 +0530 Subject: [PATCH 195/204] MOSIP-29286 --- .../KeyCloakUserAndAPIKeyGeneration.java | 43 +++++ .../ida/certificate/PartnerRegistration.java | 50 +++++- .../apirig/testrunner/MosipTestRunner.java | 8 +- .../testrig/apirig/testscripts/BioAuth.java | 10 ++ .../BioAuthWithUnblockedPartners.yml | 169 ++++++++++++++++++ .../ida/BioAuthHotListLock/EkycBioResult.hbs | 9 + .../UnBlockHotlistAPIForPartnerId.yml | 15 ++ .../testNgXmlFiles/authenticationApi.xml | 8 + 8 files changed, 303 insertions(+), 9 deletions(-) create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthWithUnblockedPartners.yml create mode 100644 automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBioResult.hbs diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java index 115d10aba27..5c0e14af952 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java @@ -20,11 +20,17 @@ public class KeyCloakUserAndAPIKeyGeneration extends AdminTestUtil { static String partnerId = PartnerRegistration.partnerId; static String emailId = PartnerRegistration.emailId; + static String emailIdForKyc = PartnerRegistration.emailIdForKyc; static String role = PartnerRegistration.partnerType; static String policyGroup = PartnerRegistration.policyGroup; static String randomAbbreviation = generateRandomAlphabeticString(4).toUpperCase(); static String policyName = AdminTestUtil.policyName; + static String policyGroup2 = AdminTestUtil.policyGroup2; + static String policyName2 = AdminTestUtil.policyName2; + + static String ekycPartnerId = PartnerRegistration.ekycPartnerId; + public static void setLogLevel() { if (ConfigManager.IsDebugEnabled()) lOGGER.setLevel(Level.ALL); @@ -39,6 +45,13 @@ public static String createKCUserAndGetAPIKey() { return createAPIKey(); } + public static String createKCUserAndGetAPIKeyForKyc() { + KeycloakUserManager.createKeyCloakUsers(ekycPartnerId, emailIdForKyc, role); + String mappingKey = submittingPartnerAndGetMappingKey(); + approvePartnerAPIKey(mappingKey); + return createAPIKey(); + } + public static String submittingPartnerAndGetMappingKey() { String url = ApplnURI + "/v1/partnermanager/partners/"+partnerId+"/policy/map"; @@ -46,6 +59,36 @@ public static String submittingPartnerAndGetMappingKey() { HashMap requestBody = new HashMap<>(); + requestBody.put("policyName", policyName2); + requestBody.put("useCaseDescription", "mapping Partner to policyName"); + + HashMap body = new HashMap<>(); + + body.put("id", GlobalConstants.STRING); + body.put(GlobalConstants.METADATA, new HashMap<>()); + body.put(GlobalConstants.REQUEST, requestBody); + body.put(GlobalConstants.REQUESTTIME, generateCurrentUTCTimeStamp()); + body.put(GlobalConstants.VERSION, GlobalConstants.STRING); + + Response response = RestClient.postRequestWithCookie(url, body, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + lOGGER.info(response); + JSONObject responseJson = new JSONObject(response.asString()); + lOGGER.info(responseJson); + JSONObject responseValue = (JSONObject) (responseJson.get("response")); + lOGGER.info(responseValue); + String mappingKey = responseValue.getString("mappingkey"); + lOGGER.info(mappingKey); + + return mappingKey; + } + + public static String submittingPartnerAndGetMappingKeyForKyc() { + String url = ApplnURI + "/v1/partnermanager/partners/"+ekycPartnerId+"/policy/map"; + + String token = kernelAuthLib.getTokenByRole("partner"); + + HashMap requestBody = new HashMap<>(); + requestBody.put("policyName", policyName); requestBody.put("useCaseDescription", "mapping Partner to policyName"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java index 599c44ccee6..2def6a0e1f1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java @@ -29,6 +29,7 @@ public class PartnerRegistration extends AdminTestUtil { static String emailId = "mosip_1" + timeStamp + "@gmail.com"; static String emailId2 = "mosip_2" + timeStamp + "@gmail.com"; static String emailId3 = "mosip_3" + timeStamp + "@gmail.com"; + static String emailIdForKyc = "mosip_4" + timeStamp + "@gmail.com"; public static String organizationName = "mosip_partnerorg" + timeStamp; public static String ekycOrganizationName = "mosip_ekyc_partner" + timeStamp; public static String deviceOrganizationName = "mosip_deviceorg" + timeStamp; @@ -37,10 +38,13 @@ public class PartnerRegistration extends AdminTestUtil { public static String ekycPartnerId = ekycOrganizationName; public static String partnerType = "AUTH_PARTNER"; static String getPartnerType = "RELYING_PARTY"; - static String getEkycPartnerType = "EKYC"; + static String getEkycPartnerType = "AUTH_PARTNER"; + static String getEkycPartnerTypeForCert = "EKYC"; public static String apiKey = ""; + public static String kycApiKey = ""; public static String mispLicKey =""; public static String policyGroup = AdminTestUtil.policyGroup; + public static String policyGroupForKyc = AdminTestUtil.policyGroup2; public static void setLogLevel() { if (ConfigManager.IsDebugEnabled()) @@ -84,17 +88,19 @@ public static String generateAndGetEkycPartnerKeyUrl() { return ConfigManager.getPartnerUrlSuffix(); } - ftmGeneration(); - deviceGeneration(); + /* + * ftmGeneration(); deviceGeneration(); + */ getAndUploadEkycCertificates(); + kycApiKey = KeyCloakUserAndAPIKeyGeneration.createKCUserAndGetAPIKeyForKyc(); if (apiKey.isEmpty() || mispLicKey.isEmpty()) { lOGGER.error("Failed to generate API key and MISP Lic key"); return ""; } - ekycPartnerKeyUrl = mispLicKey + "/" + ekycPartnerId + "/" + apiKey; + ekycPartnerKeyUrl = mispLicKey + "/" + ekycPartnerId + "/" + kycApiKey; lOGGER.info("ekycPartnerKeyUrl = " + ekycPartnerKeyUrl); @@ -131,8 +137,8 @@ public static void getAndUploadEkycCertificates() { localHostUrl = getLocalHostUrl(); } - partnerGeneration(); - JSONObject certificateValue = getCertificates(ekycPartnerId, getEkycPartnerType); + partnerKycGeneration(); + JSONObject certificateValue = getCertificates(ekycPartnerId, getEkycPartnerTypeForCert); String caCertValue = certificateValue.getString("caCertificate"); lOGGER.info(caCertValue); String interCertValue = certificateValue.getString("interCertificate"); @@ -186,6 +192,38 @@ public static void partnerGeneration() { JSONObject responseValue = (JSONObject) (responseJson.get("response")); lOGGER.info(responseValue); } + + public static void partnerKycGeneration() { + String url = ApplnURI + properties.getProperty("putPartnerRegistrationUrl"); + + String token = kernelAuthLib.getTokenByRole("partner"); + + HashMap requestBody = new HashMap<>(); + + requestBody.put("address", address); + requestBody.put("contactNumber", contactNumber); + requestBody.put("emailId", emailIdForKyc); + requestBody.put("organizationName", ekycOrganizationName); + requestBody.put(GlobalConstants.PARTNERID, ekycPartnerId); + requestBody.put("partnerType", getEkycPartnerType); + requestBody.put("policyGroup", policyGroupForKyc); + + HashMap body = new HashMap<>(); + + body.put("id", GlobalConstants.STRING); + body.put(GlobalConstants.METADATA, new HashMap<>()); + body.put(GlobalConstants.REQUEST, requestBody); + body.put(GlobalConstants.REQUESTTIME, generateCurrentUTCTimeStamp()); + body.put(GlobalConstants.VERSION, "LTS"); + + Response response = RestClient.postRequestWithCookie(url, body, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + lOGGER.info(response); + JSONObject responseJson = new JSONObject(response.asString()); + lOGGER.info(responseJson); + JSONObject responseValue = (JSONObject) (responseJson.get("response")); + lOGGER.info(responseValue); + } public static JSONObject getCertificates(String partnerId, String partnerType) { if (localHostUrl == null) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 2bd08987ade..5963351bdfd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -89,15 +89,17 @@ public static void main(String[] arg) { AdminTestUtil.getLocationData(); String partnerKeyURL = ""; - //String ekycPartnerKeyURL = ""; + String ekycPartnerKeyURL = ""; if (BaseTestCase.listOfModules.contains("auth") || BaseTestCase.listOfModules.contains(GlobalConstants.ESIGNET)) { PartnerRegistration.deleteCertificates(); CertificateGenerationUtil.getThumbprints(); AdminTestUtil.createAndPublishPolicy(); - //AdminTestUtil.createAndPublishPolicyForKyc(); partnerKeyURL = PartnerRegistration.generateAndGetPartnerKeyUrl(); + + + //AdminTestUtil.createAndPublishPolicyForKyc(); //ekycPartnerKeyURL = PartnerRegistration.generateAndGetEkycPartnerKeyUrl(); } @@ -123,7 +125,7 @@ public static void main(String[] arg) { } else if (BaseTestCase.listOfModules.contains("auth") || BaseTestCase.listOfModules.contains(GlobalConstants.ESIGNET)) { - if (partnerKeyURL.isEmpty()) + if (partnerKeyURL.isEmpty() || ekycPartnerKeyURL.isEmpty()) LOGGER.error("partnerKeyURL is null"); else startTestRunner(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java index 5ab78e280f7..3a078a59cdb 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java @@ -105,9 +105,19 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.setEndPoint( testCaseDTO.getEndPoint().replace("$PartnerKeyURL$", PartnerRegistration.partnerKeyUrl)); } + + if (testCaseDTO.getEndPoint().contains("$KycPartnerKeyURL$")) { + testCaseDTO.setEndPoint( + testCaseDTO.getEndPoint().replace("$KycPartnerKeyURL$", PartnerRegistration.ekycPartnerKeyUrl)); + } + if (testCaseDTO.getEndPoint().contains("$PartnerName$")) { testCaseDTO.setEndPoint(testCaseDTO.getEndPoint().replace("$PartnerName$", PartnerRegistration.partnerId)); } + + if (testCaseDTO.getEndPoint().contains("$KycPartnerName$")) { + testCaseDTO.setEndPoint(testCaseDTO.getEndPoint().replace("$KycPartnerName$", PartnerRegistration.ekycPartnerId)); + } String request = testCaseDTO.getInput(); request = buildIdentityRequest(request); diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthWithUnblockedPartners.yml b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthWithUnblockedPartners.yml new file mode 100644 index 00000000000..aaff721b3e3 --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/BioAuthWithUnblockedPartners.yml @@ -0,0 +1,169 @@ +BioAuth: + auth_BioAuth_Biometric_Face_With_Unblocked_Partners_Smoke_Pos: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/BioAuthResult + input: '{ + "bioSubType": "", + "bioType": "FACE", + "bioValue": "$FACE$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Face", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "true" +}' + auth_BioAuth_Biometric_RingFinger_With__Unblocked_Partners: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/BioAuthResult + input: '{ + "bioSubType": "Left RingFinger", + "bioType": "Finger", + "bioValue": "$LEFTRINGFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "true" +}' + auth_BioAuth_Biometric_LeftIndexFingerr__Unblocked_Partners: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/BioAuthResult + input: '{ + "bioSubType": "Left IndexFinger", + "bioType": "Finger", + "bioValue": "$LEFTINDEXFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "true" +}' + auth_BioAuth_Biometric_IRIS_With__Unblocked_Partners: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/EkycBioResult + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "authStatus": "true" +}' + auth_EkycBio_LeftMiddleFingerr__Unblocked_Partners: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/EkycBioResult + input: '{ + "bioSubType": "Left MiddleFinger", + "bioType": "Finger", + "bioValue": "$LEFTMIDDLEFINGER$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Finger", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' + auth_EkycBio_RIGHTIRIS_With__Unblocked_Partners: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&isKyc=true&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/BioAuthHotListLock/BioAuth + outputTemplate: ida/BioAuthHotListLock/EkycBioResult + input: '{ + "bioSubType": "Right", + "bioType": "Iris", + "bioValue": "$RIGHTIRIS$", + "deviceCode": "bc0b6848-6d45-46d1-a9bd-b334410bf823", + "dateTime": "$DATETIME$", + "deviceProviderID": "1873299273", + "deviceServiceID": "", + "deviceServiceVersion": "SB.WIN.001", + "deviceProvider": "SYNCBYTE", + "deviceProviderId": "SYNCBYTE.LTC165", + "deviceSubType": "Single", + "make": "Logitech", + "model": "4d36e96c-e325-11ce-bfc1-08002be10318", + "serialNo": "78467171", + "type": "Iris", + "transactionId": "$TRANSACTIONID$", + "timestamp": "$TIMESTAMP$" + }' + output: '{ + "kycStatus": "true" +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBioResult.hbs b/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBioResult.hbs new file mode 100644 index 00000000000..9d51fe4b7fb --- /dev/null +++ b/automationtests/src/main/resources/ida/BioAuthHotListLock/EkycBioResult.hbs @@ -0,0 +1,9 @@ +{ + "authResponse": { + "body": { + "response": { + "kycStatus": {{kycStatus}} + } + } + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPIForPartnerId.yml b/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPIForPartnerId.yml index b144357c1f4..316f8b96190 100644 --- a/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPIForPartnerId.yml +++ b/automationtests/src/main/resources/ida/UnBlockHotlistAPI/UnBlockHotlistAPIForPartnerId.yml @@ -25,6 +25,21 @@ HotlistAPI: "idType": "PARTNER_ID", "requestTime": "$TIMESTAMP$", "expiryTimestamp": "" + }' + output: '{ + "status": "UNBLOCKED" + }' + auth_HotlistAPI_All_Valid_Smoke_Unblock_MISP_KEY_sid: + endPoint: /v1/hotlist/unblock + role: hotlist + restMethod: post + inputTemplate: ida/UnBlockHotlistAPI/UnblockHotlistAPI + outputTemplate: ida/UnBlockHotlistAPI/UnblockHotlistAPIResult + input: '{ + "id": "$APIKEY$", + "idType": "PARTNER_ID", + "requestTime": "$TIMESTAMP$", + "expiryTimestamp": "" }' output: '{ "status": "UNBLOCKED" diff --git a/automationtests/testNgXmlFiles/authenticationApi.xml b/automationtests/testNgXmlFiles/authenticationApi.xml index a4430075eb3..8d0572ecfc0 100644 --- a/automationtests/testNgXmlFiles/authenticationApi.xml +++ b/automationtests/testNgXmlFiles/authenticationApi.xml @@ -286,4 +286,12 @@ + + + + + + + From 31041eb08a8e8c2c22d9e837b8bcfd41bebaf34f Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 4 Oct 2023 16:52:48 +0530 Subject: [PATCH 196/204] MOSIP-29286 --- .../ida/certificate/KeyCloakUserAndAPIKeyGeneration.java | 4 ++-- .../io/mosip/testrig/apirig/testrunner/MosipTestRunner.java | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java index 5c0e14af952..9015fd0ea6f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java @@ -59,7 +59,7 @@ public static String submittingPartnerAndGetMappingKey() { HashMap requestBody = new HashMap<>(); - requestBody.put("policyName", policyName2); + requestBody.put("policyName", policyName); requestBody.put("useCaseDescription", "mapping Partner to policyName"); HashMap body = new HashMap<>(); @@ -89,7 +89,7 @@ public static String submittingPartnerAndGetMappingKeyForKyc() { HashMap requestBody = new HashMap<>(); - requestBody.put("policyName", policyName); + requestBody.put("policyName", policyName2); requestBody.put("useCaseDescription", "mapping Partner to policyName"); HashMap body = new HashMap<>(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 5963351bdfd..d32970e9066 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -125,7 +125,8 @@ public static void main(String[] arg) { } else if (BaseTestCase.listOfModules.contains("auth") || BaseTestCase.listOfModules.contains(GlobalConstants.ESIGNET)) { - if (partnerKeyURL.isEmpty() || ekycPartnerKeyURL.isEmpty()) + if (partnerKeyURL.isEmpty()) + // if (partnerKeyURL.isEmpty() || ekycPartnerKeyURL.isEmpty()) LOGGER.error("partnerKeyURL is null"); else startTestRunner(); From 1e084fd67f1f543af6c1833523a5f5a6fefb9db8 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 4 Oct 2023 20:17:14 +0530 Subject: [PATCH 197/204] MOSIP-29286 --- .../idRepository/AddIdentity/AddIdentity.yml | 33 ++++++++++ .../RetrieveVIDByUIN/RetrieveVIDByUIN.yml | 17 +++++ .../resources/ida/AddIdentity/AddIdentity.yml | 29 +++++++++ .../ida/AuthInternalLock/AuthInternalLock.yml | 17 +++++ .../resources/ida/AuthLock/createAuthLock.yml | 31 +++++++++ .../main/resources/ida/DemoAuth/DemoAuth.yml | 64 +++++++++++++++++++ 6 files changed, 191 insertions(+) diff --git a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml index 99d280e63e9..d6e19de3f21 100644 --- a/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/idRepository/AddIdentity/AddIdentity.yml @@ -1535,6 +1535,39 @@ AddIdentity: "dateOfBirth": "1992/04/15", + "postalCode": "14022", + "email": "mosipuser123@mailinator.com", + "phone": "8249742850", + "mobileno": "8249742850", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" +}' + IdRepository_AddIdentity_WITH_biometricReferenceId_smoke_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + restMethod: post + inputTemplate: idRepository/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: idRepository/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + + "UIN": "$UIN$", + + "dateOfBirth": "1992/04/15", + "postalCode": "14022", "email": "mosipuser123@mailinator.com", "phone": "8249742850", diff --git a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml index ea502b01e92..b0cefcb5f9c 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml @@ -11,6 +11,23 @@ RetrieveVIDByUIN: }' output: '{ "vidType": "$IGNORE$" +}' + IdRepository_RetrieveVIDByUIN_With_blocked_vid_: + endPoint: /idrepository/v1/vid/uin/{UIN} + role: idrepo + checkErrorsOnlyInResponse: true + restMethod: get + inputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUIN + outputTemplate: idRepository/error + input: '{ + "UIN":"$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$" + }' + output: '{ + "errors": [ + { + "errorCode": "IDR-VID-003" + } + ] }' IdRepository_RetrieveVIDByUIN_With_Valid_Smoke_Perp: endPoint: /idrepository/v1/vid/uin/{UIN} diff --git a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml index 3247bb73cb9..8058f91afc9 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml +++ b/automationtests/src/main/resources/ida/AddIdentity/AddIdentity.yml @@ -1018,4 +1018,33 @@ AddIdentity: }' output: '{ "status":"ACTIVATED" +}' + auth_AddIdentity_lock_unlock_forever_smoke_sid_Pos: + endPoint: /idrepository/v1/identity/ + role: idrepo + regenerateHbs: true + restMethod: post + inputTemplate: ida/AddIdentity/addIdentity_$LANGNUMBER$ + outputTemplate: ida/AddIdentity/addIdentityResult + input: '{ + "value": "$BIOVALUE$", + "id": "mosip.id.create", + "registrationId": "$RID$", + "addressCopy": "Y", + "biometricReferenceId": "23452353", + "UIN": "$UIN$", + "dateOfBirth": "1970/07/08", + "postalCode": "14022", + "email": "auth_AddIdentity_Positive_demoauth_name_smoke@mosip.net", + "phone": "7019858531", + "mobileno": "7019858531", + "referenceIdentityNumber": "6789545678878", + "version": "v1", + "introducerRID": "212124324784879", + "introducerUIN": "212124324784879", + "category": "individualBiometrics", + "requesttime": "$TIMESTAMP$" +}' + output: '{ + "status":"ACTIVATED" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml b/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml index ce13c40047f..22436334e1e 100644 --- a/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml +++ b/automationtests/src/main/resources/ida/AuthInternalLock/AuthInternalLock.yml @@ -16,6 +16,23 @@ AuthInternalLock: output: '{ "message": "Notification has been sent to the provided contact detail(s)" }' + auth_AuthInternal_lock_with_explicitly_Smoke_Pos: + endPoint: /idrepository/v1/identity/authtypes/status + role: idrepo + restMethod: post + inputTemplate: ida/AuthInternalLock/authInternalLock + outputTemplate: ida/AuthInternalLock/authInternalLockResult + input: '{ + "individualId": "$ID:AddIdentity_lock_unlock_forever_smoke_sid_Pos_UIN$", + "individualIdType": "UIN", + "authType": "Bio", + "authSubType": "Iris", + "locked": true, + "unlockForSeconds": 5000 +}' + output: '{ + "message": "Notification has been sent to the provided contact detail(s)" +}' auth_AuthInternal_Lock_UIN_Unlock_DemoAuth_Smoke_Pos: endPoint: /idrepository/v1/identity/authtypes/status diff --git a/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml index 8e3b9822273..454831df73c 100644 --- a/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/ida/AuthLock/createAuthLock.yml @@ -29,6 +29,37 @@ AuthLock: "maskedMobile": "XXXXXX8531", "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" } +}' + auth_AuthLock_Valid_UIN_locked_All: + endPoint: /resident/v1/req/auth-lock + role: resident + restMethod: post + inputTemplate: ida/AuthLock/createAuthLock + outputTemplate: ida/AuthLock/createAuthLockResult + input: '{ + "transactionID": "$TRANSACTIONID$", + "individualId": "$ID:AddIdentity_lock_unlock_forever_smoke_sid_Pos_UIN$", + "individualIdType": "UIN", + "requesttime": "$TIMESTAMP$", + "id": "mosip.resident.authlock", + "version": "v1", + "authType": [{auth: "demo"},{auth: "bio-FACE"}], + "otp": "$ID:AddIdentity_lock_unlock_forever_smoke_sid_Pos_EMAIL$", + "sendOtp":{ + "transactionID": "$TRANSACTIONID$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:AddIdentity_lock_unlock_forever_smoke_sid_Pos_UIN$", + "individualIdType": "UIN", + "sendOtpReqTemplate": "ida/SendOTP/createSendOTP", + "sendOtpEndPoint": "/resident/v1/req/otp" + } + }' + output: '{ + "message": "Notification has been sent to the provided contact detail(s)", + "sendOtpResp":{ + "maskedMobile": "XXXXXX8531", + "sendOtpResTemplate":"ida/SendOTP/createSendOTPResult" + } }' auth_AuthLock_Valid_child_UIN_which_locked: endPoint: /resident/v1/req/auth-lock diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index a114bee6150..ba6c6f624db 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -1117,4 +1117,68 @@ DemoAuthNew: }' output: '{ "authStatus": "true" +}' + auth_DemoAuthValid_Smoke_with_addressCopy: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoAuth + outputTemplate: ida/DemoAuth/DemoAuthResult + input: '{ + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$", + "value": "Y", + "key": "addressCopy" + }' + output: '{ + "authStatus": "true" +}' + auth_DemoAuthValid_Smoke_with_mobileno: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoAuth + outputTemplate: ida/DemoAuth/DemoAuthResult + input: '{ + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$", + "value": "7019858531", + "key": "mobileno" + }' + output: '{ + "authStatus": "true" +}' + auth_DemoAuthValid_with_phone: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoAuth + outputTemplate: ida/DemoAuth/error + input: '{ + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$", + "value": "7019858531", + "key": "phone" + }' + output: '{ + "authStatus": "false" +}' + auth_DemoAuthValid_with_firstName: + endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ + role: resident + restMethod: post + inputTemplate: ida/DemoAuth/DemoAuth + outputTemplate: ida/DemoAuth/error + input: '{ + "name": [ + { + "language": "$PRIMARYLANG$", + "value": "TEST_FIRSTNAMEeng" + } + ], + "timestamp": "$TIMESTAMP$", + "transactionId": "$TRANSACTIONID$" + }' + output: '{ + "authStatus": "true" }' \ No newline at end of file From b84424d0e690dc87dd8616152da81515e70ebc8a Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 4 Oct 2023 20:26:13 +0530 Subject: [PATCH 198/204] MOSIP-29513 --- .../OAuthDetailsRequestVCI.hbs | 17 + .../OAuthDetailsRequestVCI.yml | 500 ++++++++++++++++++ .../OAuthDetailsRequestVCIResult.hbs | 1 + .../testNgXmlFiles/esignetSuite.xml | 8 + 4 files changed, 526 insertions(+) create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs new file mode 100644 index 00000000000..6dec068b531 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.hbs @@ -0,0 +1,17 @@ +{ + "requestTime": "{{requestTime}}", + "request": { + "clientId": "{{clientId}}", + "scope": "{{scope}}", + "responseType": "{{responseType}}", + "redirectUri": "{{redirectUri}}", + "display": "{{display}}", + "prompt": "{{prompt}}", + "acrValues": "{{acrValues}}", + "nonce" : "{{nonce}}", + "state" : "{{state}}", + "claimsLocales" : "{{claimsLocales}}", + "codeChallenge" : "{{codeChallenge}}", + "codeChallengeMethod" : "{{codeChallengeMethod}}" + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml new file mode 100644 index 00000000000..d1a6b369d77 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -0,0 +1,500 @@ +OAuthDetailsRequestVCIVidNegTC: + ESignet_OAuthDetailsRequest_VCI_Vid_Empty_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_SpaceVal_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": " ", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Diff_Scope_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "openid profile", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Invalid_Scope_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "openid profile, mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_scope" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Invalid_Code_Challenge_Method_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "sdgfdg" +}' + output: '{ + "errors": [ + { + "errorCode": "unsupported_pkce_challenge_method" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Empty_Code_Challenge_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_pkce_challenge" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_SpaceVal_Code_Challenge_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": " ", + "codeChallengeMethod": "S256" +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_pkce_challenge" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Empty_Code_Challenge_Method_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "" +}' + output: '{ + "errors": [ + { + "errorCode": "unsupported_pkce_challenge_method" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_SpaceVal_Code_Challenge_Method_Neg: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/error + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": " " +}' + output: '{ + "errors": [ + { + "errorCode": "unsupported_pkce_challenge_method" + } + ] +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Long_Code_Challenge_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe2Krathy2lc9BgD5k1uZk0PKXeGuaKboSrJfdzKZoQhmMKA9Blx7YfkCaHahoNIOggCU3iGhHg6TxJn1cUztkt6G8HlkOjiMFfknDlKob4ZJR290EOraRCmqdonPtZkG2xOqqx0tqHBxZ6gXlIYJwpDQ8rzr1SsYe", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Missing_Code_Challenge_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$REMOVE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Missing_Code_Challenge_Method_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "$REMOVE$" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_Missing_Code_Challenge_And_Method_Pos: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$REMOVE$", + "codeChallengeMethod": "$REMOVE$" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/testNgXmlFiles/esignetSuite.xml b/automationtests/testNgXmlFiles/esignetSuite.xml index 339d64682bf..9760ccc1b46 100644 --- a/automationtests/testNgXmlFiles/esignetSuite.xml +++ b/automationtests/testNgXmlFiles/esignetSuite.xml @@ -554,6 +554,14 @@ + + + + + + + From 2d4c921f1f61abf9fdc28f6f9b842856474216e9 Mon Sep 17 00:00:00 2001 From: kaifk468 <74772315+kaifk468@users.noreply.github.com> Date: Thu, 5 Oct 2023 14:06:34 +0530 Subject: [PATCH 199/204] added create-vci-exchange api (#1100) --- .../controller/AuthRequestController.java | 75 ++++++++++++++++--- .../src/main/resources/application.properties | 3 +- 2 files changed, 68 insertions(+), 10 deletions(-) diff --git a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/AuthRequestController.java b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/AuthRequestController.java index c5c37461221..a45c3a29f27 100644 --- a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/AuthRequestController.java +++ b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/AuthRequestController.java @@ -47,6 +47,7 @@ import javax.crypto.NoSuchPaddingException; import javax.xml.bind.DatatypeConverter; +import io.mosip.testrig.authentication.demo.service.dto.*; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.io.IOUtils; import org.bouncycastle.operator.OperatorCreationException; @@ -62,12 +63,7 @@ import org.springframework.http.ResponseEntity; import org.springframework.lang.NonNull; import org.springframework.lang.Nullable; -import org.springframework.web.bind.annotation.DeleteMapping; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.PostMapping; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.bind.annotation.*; import org.springframework.web.client.HttpServerErrorException; import org.springframework.web.client.RestClientException; import org.springframework.web.client.RestTemplate; @@ -90,9 +86,6 @@ import io.mosip.kernel.core.util.DateUtils; import io.mosip.kernel.core.util.HMACUtils2; import io.mosip.testrig.authentication.demo.service.controller.Encrypt.SplittedEncryptedData; -import io.mosip.testrig.authentication.demo.service.dto.CertificateChainResponseDto; -import io.mosip.testrig.authentication.demo.service.dto.EncryptionRequestDto; -import io.mosip.testrig.authentication.demo.service.dto.EncryptionResponseDto; import io.mosip.testrig.authentication.demo.service.helper.CertificateTypes; import io.mosip.testrig.authentication.demo.service.helper.KeyMgrUtil; import io.mosip.testrig.authentication.demo.service.helper.PartnerTypes; @@ -177,6 +170,8 @@ public class AuthRequestController { private static final String IDA_KYC_EXCHANGE_REQUEST_TEMPLATE = "ida.kycExchangeRequest.template"; + private static final String IDA_VCI_EXCHANGE_REQUEST_TEMPLATE = "ida.vciExchangeRequest.template"; + private static final String ID = "id"; private static final String CLASSPATH = "classpath"; @@ -574,6 +569,68 @@ public ResponseEntity createKycExchangeRequest(@RequestParam(name = ID, String.format(IdAuthenticationErrorConstants.MISSING_INPUT_PARAMETER.getErrorMessage(), IDENTITY)); } } + + @PostMapping(path = "/create-vci-exchange-request", consumes = MediaType.APPLICATION_JSON_VALUE, produces = { + MediaType.APPLICATION_JSON_VALUE }) + public ResponseEntity createVciExchangeRequest(@RequestParam(name = ID, required = true) @Nullable String id, + @RequestParam(name = ID_TYPE, required = false) @Nullable String idType, + @RequestParam(name = "Authtype", required = false) @Nullable String reqAuth, + @RequestParam(name = TRANSACTION_ID, required = false) @Nullable String transactionId, + @RequestParam(name = "requestTime", required = false) @Nullable String requestTime, + @RequestParam(name = "vcFormat", required = false) @Nullable String vcFormat, + @RequestParam(name = "credSubjectId", required = false)@Nullable String credSubjectId, + @RequestParam(name = "vcAuthToken", required = false)@Nullable String vcAuthToken, + @RequestParam(name = "keyFileNameByPartnerName", required = false)boolean keyFileNameByPartnerName, + @RequestParam(name = "partnerName", required = false)@Nullable String partnerName, + @RequestBody Map request, + @RequestParam(name = "certsDir", required = false) String certsDir, + @RequestParam(name = "moduleName", required = false) String moduleName) throws Exception { + String authRequestTemplate = environment.getProperty(IDA_VCI_EXCHANGE_REQUEST_TEMPLATE); + Map reqValues = new HashMap<>(); + + if (requestTime == null) { + requestTime = DateUtils.getUTCCurrentDateTimeString(environment.getProperty("datetime.pattern")); + } + + reqValues.put(ID, id); + reqValues.put("individualIdType", idType == null || idType.trim().length() == 0 ? IdType.UIN.toString() : idType); + reqValues.put(AUTH_TYPE, reqAuth); + reqValues.put(TIMESTAMP, requestTime); + reqValues.put(TXN, transactionId == null ? "1234567890" : transactionId); + reqValues.put(VER, environment.getProperty(IDA_API_VERSION)); + reqValues.put("vcFormat", vcFormat); + reqValues.put("credSubjectId", credSubjectId); + reqValues.put("vcAuthToken", vcAuthToken); + + StringWriter writer = new StringWriter(); + InputStream templateValue; + if (request != null && request.size() > 0) { + templateValue = templateManager + .merge(new ByteArrayInputStream(authRequestTemplate.getBytes(StandardCharsets.UTF_8)), reqValues); + + if (templateValue != null) { + IOUtils.copy(templateValue, writer, StandardCharsets.UTF_8); + String res = writer.toString(); + ObjectNode response = mapper.readValue(res.getBytes(), ObjectNode.class); + + HttpHeaders httpHeaders = new HttpHeaders(); + String responseStr = response.toString(); + + String rpSignature = signRequest(PartnerTypes.MISP, partnerName, keyFileNameByPartnerName, responseStr, certsDir, moduleName); + httpHeaders.add("signature", rpSignature); + return new ResponseEntity<>(responseStr, httpHeaders, HttpStatus.OK); + } else { + throw new IdAuthenticationBusinessException( + IdAuthenticationErrorConstants.MISSING_INPUT_PARAMETER.getErrorCode(), String.format( + IdAuthenticationErrorConstants.MISSING_INPUT_PARAMETER.getErrorMessage(), TEMPLATE)); + } + } else { + throw new IdAuthenticationBusinessException( + IdAuthenticationErrorConstants.MISSING_INPUT_PARAMETER.getErrorCode(), + String.format(IdAuthenticationErrorConstants.MISSING_INPUT_PARAMETER.getErrorMessage(), IDENTITY)); + } + } + /** * this method is used to create the auth request. diff --git a/authentication-demo-service/src/main/resources/application.properties b/authentication-demo-service/src/main/resources/application.properties index cf22ff0f99e..0ca94feea60 100644 --- a/authentication-demo-service/src/main/resources/application.properties +++ b/authentication-demo-service/src/main/resources/application.properties @@ -20,6 +20,7 @@ ida-demo.api.version=v1 server.port = 8082 ida.authRequest.template={"consentObtained":true,"id":"mosip.identity.$authType","individualId":"$id","keyIndex":"string","request":"$encRequest","requestHMAC":"$encHmac","requestSessionKey":"$encSessionKey","requestTime":"$timestamp","transactionID":"$txn","version":"$ver","domainUri":"$domainUri","env":"$env","specVersion":"1.0","thumbprint":"$thumbprint"} ida.kycExchangeRequest.template={"consentObtained":["true"],"locales":["eng"],"id":"mosip.identity.$authType","individualId":"$id","individualIdType":"$individualIdType","kycToken":"$kycToken","respType":"$respType","metadata":"$request","requestTime":"$timestamp","transactionID":"$txn","version":"$ver"} +ida.vciExchangeRequest.template={"consentObtained":["true"],"locales":["eng"],"id":"mosip.identity.$authType","individualId":"$id","individualIdType":"$individualIdType","kycToken":"$kycToken","respType":"$respType","metadata":"$request","requestTime":"$timestamp","transactionID":"$txn","version":"$ver","vcAuthToken":"$vcAuthToken","credSubjectId":"$credSubjectId","vcAuthToken":"$vcAuthToken","vcFormat":"$vcFormat"} otpRequestTemplate={\ "id": "$reqId",\ "individualId": "$id",\ @@ -64,7 +65,7 @@ ida.api.version=1.0 javax.persistence.jdbc.driver=org.postgresql.Driver javax.persistence.jdbc.url=jdbc:postgresql://localhost:5432/ida_db javax.persistence.jdbc.user=postgres -javax.persistence.jdbc.password=admin +javax.persistence.jdbc.password=postgres # ********* Hibernate Properties *********** From 87aea106370c2e0abaef73775ed3080cf5a3c07d Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 5 Oct 2023 19:44:06 +0530 Subject: [PATCH 200/204] MOSIP-29513 --- .../AuthenticateUserVCI.hbs | 15 ++ .../AuthenticateUserVCI.yml | 231 ++++++++++++++++++ .../AuthenticateUserVCIResult.hbs | 1 + .../AuthorizationCodeVCI.hbs | 19 ++ .../AuthorizationCodeVCI.yml | 176 +++++++++++++ .../AuthorizationCodeVCIResult.hbs | 1 + .../OAuthDetailsRequestVCI.yml | 52 ++++ .../testNgXmlFiles/esignetSuite.xml | 30 +++ 8 files changed, 525 insertions(+) create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml create mode 100644 automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs new file mode 100644 index 00000000000..887633e1120 --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.hbs @@ -0,0 +1,15 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "individualId": "{{individualId}}", + "challengeList" : [ + { + "authFactorType" : "{{authFactorType}}", + "challenge" : "{{challenge}}", + "format": "alpha-numeric" + } + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml new file mode 100644 index 00000000000..6dbb5b8225e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI.yml @@ -0,0 +1,231 @@ +AuthenticateUserVCIVidNegTC: + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen1_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen2_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen3_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen4_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen5_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen6_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' + + ESignet_AuthenticateUserVCI_Vid_Otp_NegAuthCodeScen7_Valid_Smoke: + endPoint: /v1/esignet/authorization/authenticate + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCI + outputTemplate: esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResultResult + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "authFactorType" : "OTP", + "challenge" : "$ID:AddIdentity_Valid_Params_VCI_Vid_Inv_Scen_smoke_Pos_EMAIL$", + "sendOtp":{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid_transactionId$", + "individualId": "$ID:Generate_Perpetual_VID_VCI_Invalid_Scen_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendOtp/SendOtp", + "sendOtpEndPoint": "/v1/esignet/authorization/send-otp" + } + }' + output: '{ + "sendOtpResp":{ + "maskedMobile": "XXXXXX3210", + "sendOtpResTemplate":"esignet/SendOtp/SendOtpResult", + "maskedEmail": "$IGNORE$" + } +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthenticateUserVCI/AuthenticateUserVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs new file mode 100644 index 00000000000..491dca1ba1f --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.hbs @@ -0,0 +1,19 @@ +{ + "encodedHash": "{{encodedHash}}", + "requestTime": "{{requestTime}}", + "request": { + "transactionId": "{{transactionId}}", + "acceptedClaims": [ + {{#each acceptedClaims}} + "{{claim}}" + {{#unless @last}},{{/unless}} + {{/each}} + ], + "permittedAuthorizeScopes": [ + {{#each permittedAuthorizeScopes}} + "{{scope}}" + {{#unless @last}},{{/unless}} + {{/each}} + ] + } +} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml new file mode 100644 index 00000000000..dd9f17a3bca --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI.yml @@ -0,0 +1,176 @@ +AuthorizationCodeVCIVidNegTC: + ESignet_AuthorizationCode_VCI_Vid_Invalid_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen1_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "sdfsfd"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_Empty_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen2_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: ""}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_Invalid_Comma_Separated_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen3_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "sdfaf, asdf"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_Invalid_Diff_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_Diff_Scope_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_Diff_Scope_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: "mosip_identity_vc_ldp"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_Invalid_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen4_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: "name"}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_SpaceVal_Scope: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen5_Valid_Smoke_sid_transactionId$", + "permittedAuthorizeScopes": [{scope: " "}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_permitted_scope" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_Empty_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: ""}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] +}' + + ESignet_AuthorizationCode_VCI_Vid_spaceVal_Claim_Neg: + endPoint: /v1/esignet/authorization/auth-code + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + validityCheckRequired: true + inputTemplate: esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCI + outputTemplate: esignet/error + input: '{ + "encodedHash": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid_encodedResp$", + "requestTime": "$TIMESTAMP$", + "transactionId": "$ID:OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid_transactionId$", + "acceptedClaims": [{claim: " "}] +}' + output: '{ + "errors": [ + { + "errorCode": "invalid_accepted_claim" + } + ] +}' \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs new file mode 100644 index 00000000000..9e26dfeeb6e --- /dev/null +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/AuthorizationCodeVCI/AuthorizationCodeVCIResult.hbs @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml index d1a6b369d77..be05d56276c 100644 --- a/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml +++ b/automationtests/src/main/resources/esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI.yml @@ -497,4 +497,56 @@ OAuthDetailsRequestVCIVidNegTC: }' output: '{ +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen6_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + +}' + + ESignet_OAuthDetailsRequest_VCI_Vid_NegAuthCodeScen7_Valid_Smoke_sid: + endPoint: /v1/esignet/authorization/v2/oauth-details + role: resident + restMethod: post + checkErrorsOnlyInResponse: true + inputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCI + outputTemplate: esignet/VCIVidNegTC/OAuthDetailsRequestVCI/OAuthDetailsRequestVCIResult + input: '{ + "requestTime": "$TIMESTAMP$", + "clientId": "$ID:CreateOIDCClient_all_Valid_Smoke_sid_clientId$", + "scope": "mosip_identity_vc_ldp", + "responseType": "code", + "redirectUri": "$IDPREDIRECTURI$", + "display": "popup", + "prompt": "login", + "acrValues": "mosip:idp:acr:generated-code mosip:idp:acr:linked-wallet mosip:idp:acr:biometrics", + "nonce": "973eieljzng", + "state": "eree2311", + "claimsLocales": "en", + "codeChallenge": "$CODECHALLENGE$", + "codeChallengeMethod": "S256" +}' + output: '{ + }' \ No newline at end of file diff --git a/automationtests/testNgXmlFiles/esignetSuite.xml b/automationtests/testNgXmlFiles/esignetSuite.xml index 9760ccc1b46..58f71048b71 100644 --- a/automationtests/testNgXmlFiles/esignetSuite.xml +++ b/automationtests/testNgXmlFiles/esignetSuite.xml @@ -562,6 +562,21 @@ + + + + + + + + + + + + + @@ -588,6 +603,21 @@
Test# Total# Passed# Skipped# FailedTime (ms)Included GroupsExcluded GroupsIncluded GroupsExcluded Groups
Total
"); writer.print(Utils.escapeHtml(suiteResult.getSuiteName() + "-" + getCommitId())); writer.print(GlobalConstants.TRTR); - + + writer.print("
");
+			writer.print(Utils.escapeHtml("Server Component Details " + AdminTestUtil.getServerComponentsDetails()));
+			writer.print("
"); + writer.print(GlobalConstants.TRTR); + for (TestResult testResult : suiteResult.getTestResults()) { int passedTests = testResult.getPassedTestCount(); int skippedTests = testResult.getSkippedTestCount(); From ef7f9f56c8b3bae4233b6c1c39c647595639716e Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 3 Aug 2023 12:24:09 +0530 Subject: [PATCH 006/204] MOSIP-28633 --- .../resources/esignet/WalletBinding/WalletBinding.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml b/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml index e7929115448..3bd495d51a4 100644 --- a/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml +++ b/automationtests/src/main/resources/esignet/WalletBinding/WalletBinding.yml @@ -510,7 +510,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "key_binding_failed", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "errorMessage": "request.challengeList[0].authFactorType: invalid_auth_factor_type" } ], @@ -846,7 +846,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "unsupported_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "errorMessage": "request.format: unsupported_challenge_format" } ], @@ -1770,7 +1770,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "key_binding_failed", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "errorMessage": "request.challengeList[0].authFactorType: invalid_auth_factor_type" } ], @@ -2106,7 +2106,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "unsupported_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "errorMessage": "request.format: unsupported_challenge_format" } ], From 6a1c9f72f5adda336057044018c9cc9da2fa0148 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 3 Aug 2023 12:38:26 +0530 Subject: [PATCH 007/204] MOSIP-24680 --- .../apirig/customReport/EmailableReport.java | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index 3198faba7ee..4f9cc828542 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -206,18 +206,10 @@ protected void writeSuiteSummary() { totalDuration = 0; writer.print(""); - writer.print(""); - writer.print(""); - writer.print(""); - writer.print(""); - writer.print(""); - writer.print(""); - writer.print(""); - writer.print(""); - writer.print(GlobalConstants.TR); + int testIndex = 0; - for (SuiteResult suiteResult : suiteResults) { + for (SuiteResult suiteResult : suiteResults) { writer.print(""); + writer.print(""); + writer.print(""); + writer.print(""); + writer.print(""); + writer.print(""); + writer.print(""); + writer.print(""); + writer.print(GlobalConstants.TR); + for (TestResult testResult : suiteResult.getTestResults()) { int passedTests = testResult.getPassedTestCount(); int skippedTests = testResult.getSkippedTestCount(); From cdce479eb7151b4e8fa9847b8d63bb80b2f0f22b Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 3 Aug 2023 13:02:58 +0530 Subject: [PATCH 008/204] MOSIP-28653 --- .../mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java | 5 +++++ .../src/main/resources/resident/AuthHistory/AuthHistory.yml | 6 ++++++ 2 files changed, 11 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index a1c902ca6b3..e2542996aad 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4606,6 +4606,11 @@ public static String getRegprocWaitFromActuator() { public static String isTestCaseValidForExecution(TestCaseDTO testCaseDTO) { String testCaseName = testCaseDTO.getTestCaseName(); + if ((!ConfigManager.IseSignetDeployed()) && BaseTestCase.currentModule.equalsIgnoreCase("resident") + && testCaseName.contains("_SignJWT_")) { + throw new SkipException("esignet module is not deployed"); + } + if ((!ConfigManager.IseSignetDeployed()) && BaseTestCase.currentModule.equalsIgnoreCase("resident") && (testCaseDTO.getRole() != null && (testCaseDTO.getRole().equalsIgnoreCase("residentNew") || testCaseDTO.getRole().equalsIgnoreCase("residentNewVid")))) { diff --git a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml index 873b8ec12fc..4a675fe38b3 100644 --- a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml +++ b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml @@ -552,6 +552,12 @@ AuthHistory: } ], "sendOtpResp":{ + "errors": [ + { + "errorCode": "IDA-OTA-008", + "message": "$IGNORE$" + } + ], "sendOtpResTemplate":"resident/error" } }' \ No newline at end of file From 6e6d9e828bbb2390174893be469ce4650e27c7c6 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 3 Aug 2023 16:15:15 +0530 Subject: [PATCH 009/204] MOSIP-28782 --- .../apirig/admin/fw/util/AdminTestUtil.java | 24 +++++++++---------- .../fw/util/EncryptionDecrptionUtil.java | 4 ++-- .../apirig/authentication/e2e/E2EReport.java | 2 +- .../fw/precon/XmlPrecondtion.java | 4 ++-- .../fw/util/AuthPartnerProcessor.java | 2 +- .../authentication/fw/util/AuthTestsUtil.java | 6 ++--- .../fw/util/BiometricDataUtility.java | 2 +- .../fw/util/OutputValidationUtil.java | 2 +- .../customReport/CustomTestNGReporter.java | 8 +++---- .../apirig/customReport/EmailableReport.java | 4 ++-- .../testrig/apirig/dbaccess/AuditDbRead.java | 2 +- .../apirig/kernel/service/AssertKernel.java | 2 +- .../apirig/kernel/util/CommonLibrary.java | 6 ++--- .../kernel/util/KernelAuthentication.java | 2 +- .../kernel/util/KeycloakUserManager.java | 4 ++-- .../apirig/kernel/util/Translator.java | 2 +- .../service/JSONUtil.java | 6 ++--- .../util/RegProcApiRequests.java | 10 ++++---- .../apirig/report/CustomTestNGReporter.java | 8 +++---- .../testrig/apirig/service/AssertIda.java | 2 +- .../testrig/apirig/service/AssertKernel.java | 2 +- .../apirig/testrunner/HealthChecker.java | 4 ++-- .../apirig/testrunner/MockSMTPListener.java | 2 +- .../apirig/testrunner/MosipTestRunner.java | 6 ++--- .../testrig/apirig/testscripts/BioAuth.java | 2 +- .../apirig/testscripts/BioAuthOld.java | 4 ++-- .../apirig/testscripts/EsignetBioAuth.java | 2 +- .../apirig/testscripts/MultiFactorAuth.java | 2 +- .../testrig/apirig/testscripts/OtpAuth.java | 2 +- .../apirig/testscripts/OtpAuthNew.java | 2 +- .../PostWithAutogenIdWithOtpGenerate.java | 2 +- .../PostWithBodyWithOtpGenerate.java | 2 +- 32 files changed, 67 insertions(+), 67 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index e2542996aad..0b5f45db3a9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -954,7 +954,7 @@ protected Response postWithBodyAndCookieForAutoGeneratedIdForUrlEncoded(String u try { map = mapper.readValue(inputJson, Map.class); } catch (JsonProcessingException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } logger.info(GlobalConstants.POST_REQ_URL + url); logger.info(inputJson); @@ -1162,7 +1162,7 @@ public String encodeBase64(String value) { encodedStr = encoder.encodeToString(value.getBytes()); return encodedStr; } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); return "Error While EncodeingBase64"; } @@ -1192,7 +1192,7 @@ protected Response postWithFormPathParamAndFile(String url, String jsonInput, St try { formParams.put(GlobalConstants.REQUEST, encodeBase64(req.toString())); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } else { pathParams.put(GlobalConstants.PREREGISTRATIONID, req.get(GlobalConstants.PREREGISTRATIONID).toString()); @@ -2528,7 +2528,7 @@ public String getJsonFromTemplate(String input, String template, boolean readFil Context context = Context.newBuilder(map).build(); resultJson = compiledTemplate.apply(context); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return resultJson; } @@ -2971,7 +2971,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { oidcJWKKey1 = RSAKey.parse(oidcJWKKeyString); logger.info("oidcJWKKey1 =" + oidcJWKKey1); } catch (java.text.ParseException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } JSONObject request = new JSONObject(jsonString); String clientId = null; @@ -3191,7 +3191,7 @@ public String generateIdentityJson(String testCaseName) { try { finalObject.put(GlobalConstants.IDENTITY, parser.parse(finalString)); } catch (ParseException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } return Base64.getEncoder().encodeToString(finalObject.toString().getBytes()); @@ -3393,7 +3393,7 @@ private static File updateCSV(String fileToUpdate, String replace, int row, int csvBody.get(row)[col] = replace; csvWriter.writeAll(csvBody); } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return inputFile; } @@ -3416,7 +3416,7 @@ public String generateSignatureWithRequest(String request, String partnerId) { singResponse = sign(request, false, true, false, null, getKeysDirPath(), partnerId); } catch (NoSuchAlgorithmException | UnrecoverableEntryException | KeyStoreException | CertificateException | OperatorCreationException | JoseException | IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return singResponse; @@ -3928,7 +3928,7 @@ else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { } } catch (NullPointerException | IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } finally { closeFileWriter(fileWriter1); closeFileWriter(fileWriter2); @@ -4099,7 +4099,7 @@ else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { } } catch (NullPointerException | IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } finally { closeFileWriter(fileWriter1); closeFileWriter(fileWriter2); @@ -4283,7 +4283,7 @@ else if (objIDJson3.equals(GlobalConstants.IDSCHEMAVERSION)) { } } catch (IOException | NullPointerException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } finally { closeFileWriter(fileWriter1); closeFileWriter(fileWriter2); @@ -4421,7 +4421,7 @@ public static void writeFileAsString(File fileName, String content) { FileUtils.touch(fileName);// File got created FileUtils.writeStringToFile(fileName, content, StandardCharset.UTF_8.name()); } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java index 9e979d91b25..5a8c5cfd765 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java @@ -63,7 +63,7 @@ public static void getThumbprints() { internalThumbPrint = getCertificateThumbprint(getIdaCertificate(appId, properties.getProperty("internalrefId"))); idaFirThumbPrint = getCertificateThumbprint(getIdaCertificate(appId, properties.getProperty("idaFirRefId"))); } catch (Exception e) { - lOGGER.error(e.getStackTrace()); + lOGGER.error(e.getMessage()); } } @@ -407,7 +407,7 @@ public boolean validateThumbPrint( String thumbPrint, String partnerId) { try { expectedThumbPrint = getCertificateThumbprint(getPartnerCertificate(partnerId)); } catch (Exception e) { - lOGGER.error(e.getStackTrace()); + lOGGER.error(e.getMessage()); } return expectedThumbPrint.equals(thumbPrint); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/e2e/E2EReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/e2e/E2EReport.java index eed8b4379ea..a863f2b1c09 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/e2e/E2EReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/e2e/E2EReport.java @@ -46,7 +46,7 @@ private Map getE2eAuthTestReport(List suites) { } } } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } finally { return e2eReport; } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/precon/XmlPrecondtion.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/precon/XmlPrecondtion.java index feae0d1cf46..cb70d646c89 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/precon/XmlPrecondtion.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/precon/XmlPrecondtion.java @@ -223,7 +223,7 @@ private static void updateNodeValue(XPath xpath, String normalisedExpression, St } } } catch (Exception e) { - XMLPRECONDTION_LOGGER.error(e.getStackTrace()); + XMLPRECONDTION_LOGGER.error(e.getMessage()); } } @@ -247,7 +247,7 @@ private static void updateAttributeValue(XPath xpath, String expression, String } } } catch (Exception e) { - XMLPRECONDTION_LOGGER.error(e.getStackTrace()); + XMLPRECONDTION_LOGGER.error(e.getMessage()); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthPartnerProcessor.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthPartnerProcessor.java index fb3573b4835..79bd43a8f92 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthPartnerProcessor.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthPartnerProcessor.java @@ -44,7 +44,7 @@ public static void startProcess() { while ((line = bis.readLine()) != null) DEMOAPP_LOGGER.info(line); } catch (IOException e) { - DEMOAPP_LOGGER.error(e.getStackTrace()); + DEMOAPP_LOGGER.error(e.getMessage()); } }; new Thread(startDemoAppTask).start(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java index 708bd1053b9..2a3bea66edd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java @@ -152,7 +152,7 @@ protected boolean postRequestAndGenerateOuputFile(File[] listOfFiles, String url outputStream.write(responseJson.getBytes()); } catch (Exception e) { bReturn = false; - IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getStackTrace()); + IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); break; } } @@ -191,7 +191,7 @@ protected boolean postRequestAndGenerateOuputFileForIntenalAuth(File[] listOfFil outputStream.write(response.asString().getBytes()); } catch (Exception e) { bReturn = false; - IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getStackTrace()); + IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); break; } } @@ -1426,7 +1426,7 @@ protected boolean patchRequestAndGenerateOuputFileForIntenalAuth(File[] listOfFi outputStream.write(response.asString().getBytes()); } catch (Exception e) { bReturn = false; - IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getStackTrace()); + IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); break; } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java index 552c62c6ab1..5f641e823d6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/BiometricDataUtility.java @@ -126,7 +126,7 @@ private static String getSignedData(String identityDataBlock) { JWSValidation jws = new JWSValidation(); return jws.jwsSign(identityDataBlock, privateKey, certificate); } catch (Exception e) { - logger.error("Exception Occured in signing the bio data:" + e.getStackTrace()); + logger.error("Exception Occured in signing the bio data:" + e.getMessage()); return "Automation error occured: "+e.getMessage(); }finally { AdminTestUtil.closeInputStream(pkeyfis); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index fcc387fd432..794b452fae3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -416,7 +416,7 @@ else if (!actualMap.get(entry.getKey()).equals(entry.getValue())) { } }catch(Exception e) { - OUTPUTVALIDATION_LOGGER.error(e.getStackTrace()); + OUTPUTVALIDATION_LOGGER.error(e.getMessage()); } } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/CustomTestNGReporter.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/CustomTestNGReporter.java index 56e0732e641..56ef82e701d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/CustomTestNGReporter.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/CustomTestNGReporter.java @@ -57,7 +57,7 @@ public void generateReport(List xmlSuites, List suites, String }catch(Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } finally { AdminTestUtil.closeFileWriter(fileWriter); @@ -83,7 +83,7 @@ private String readEmailabelReportTemplate() } } catch (NullPointerException |IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); }finally{ AdminTestUtil.closeBufferedReader(bufferedReader); AdminTestUtil.closeFileReader(fileReader); @@ -172,7 +172,7 @@ private String getTestSuiteSummary(List suites) { } } } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return retBuf.toString(); } @@ -235,7 +235,7 @@ private String getTestMehodSummary(List suites) { } } } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return retBuf.toString(); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index 4f9cc828542..01d0728452a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -111,7 +111,7 @@ public void generateReport(List xmlSuites, List suites, String LOG.info("isStoreSuccess:: " + isStoreSuccess); } catch (Exception e) { LOG.info("error occured while pushing the object" + e.getLocalizedMessage()); - LOG.error(e.getStackTrace()); + LOG.error(e.getMessage()); } if (isStoreSuccess) { LOG.info("Pushed file to S3"); @@ -136,7 +136,7 @@ private String getCommitId() { + properties.getProperty("git.branch"); } catch (IOException e) { - LOG.error(e.getStackTrace()); + LOG.error(e.getMessage()); return ""; } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java index a9519716a54..9ba85d3af20 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/dbaccess/AuditDbRead.java @@ -47,7 +47,7 @@ public static Session getDataBaseConnection(String dbName) { catch (HibernateException | IOException e) { logger.info("Exception in Database Connection with following message: "); logger.info(e.getMessage()); - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); Assert.assertTrue(false, "Exception in creating the sessionFactory"); }catch (NullPointerException e) { Assert.assertTrue(false, "Exception in getting the session"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/service/AssertKernel.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/service/AssertKernel.java index b0264cc21fa..8841c7065df 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/service/AssertKernel.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/service/AssertKernel.java @@ -139,7 +139,7 @@ public boolean jsonComparison(Object expectedResponseBody, Object actualResponse } } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } logger.info(GlobalConstants.EQUAL); return true; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index 664731a8940..39c0b4e0a19 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -72,7 +72,7 @@ public void checkResponseUTCTime(Response response) { } } catch (java.text.ParseException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } @@ -132,7 +132,7 @@ public JSONObject readJsonData(String path, boolean isRelative) { jsonData = (JSONObject) new JSONParser().parse(new InputStreamReader(inputStream, StandardCharsets.UTF_8)); } catch (FileNotFoundException e) { logger.info("error while reading the file : " + e.getLocalizedMessage() ); - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); logger.info("File Not Found at the given path"); } catch (IOException | ParseException | NullPointerException e) { @@ -253,7 +253,7 @@ public String removeJsonElement(String readFilePath,ArrayList eleToRemov } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return jsnString; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java index ca84dae3f05..a55f601d6e1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java @@ -179,7 +179,7 @@ public HashMap getAuthFromEsignet(File fileName) { try { ESignetCookiesFileString = FileUtils.readFileToString(fileName, StandardCharset.UTF_8); } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } org.json.JSONObject jsonCookies = new org.json.JSONObject(ESignetCookiesFileString); tokens.put(GlobalConstants.ACCESSTOKEN, jsonCookies.get(GlobalConstants.ACCESSTOKEN).toString()); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java index 90251ad59d8..6ee302cffdd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java @@ -296,7 +296,7 @@ public static void createUsers(String userid, String pwd, String rolenum, Map valueMap, Stri logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return getResponse; } @@ -226,7 +226,7 @@ public boolean checkResponseTime(Response actualResponse) { } } catch (java.text.ParseException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return utcCheck; @@ -267,7 +267,7 @@ public Response postRequestWithRequestResponseHeaders(String url, Object body, S .response(); return postResponse; } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return null; } @@ -282,7 +282,7 @@ public Response postRequestToSign(String url, Object body, String contentHeader, .contentType(contentHeader).accept(acceptHeader).log().all().when().post(ApplnURI + url).then() .log().all().extract().response(); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } return postResponse; } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/report/CustomTestNGReporter.java b/automationtests/src/main/java/io/mosip/testrig/apirig/report/CustomTestNGReporter.java index 084f6b6f8bb..2139f5663be 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/report/CustomTestNGReporter.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/report/CustomTestNGReporter.java @@ -74,7 +74,7 @@ public void generateReport(List xmlSuites, List suites, String fileWriter = new FileWriter(targetFile); fileWriter.write(finalcustomReport); } catch (NullPointerException | IOException e) { - CustomTestNGReporterLog.error(e.getStackTrace()); + CustomTestNGReporterLog.error(e.getMessage()); } finally { AdminTestUtil.closeFileWriter(fileWriter); } @@ -104,7 +104,7 @@ private StringBuffer readEmailabelReportTemplate() { } } catch (NullPointerException | IOException e) { - CustomTestNGReporterLog.error(e.getStackTrace()); + CustomTestNGReporterLog.error(e.getMessage()); } finally { AdminTestUtil.closeBufferedReader(bufferedReader); AdminTestUtil.closeFileReader(fileReader); @@ -217,7 +217,7 @@ private String getTestSuiteSummary(List suites) { retBuf.append(""); } catch (Exception e) { - CustomTestNGReporterLog.error(e.getStackTrace()); + CustomTestNGReporterLog.error(e.getMessage()); } return retBuf.toString(); } @@ -311,7 +311,7 @@ private String getTestMethodSummary(List suites) { } } } catch (Exception e) { - CustomTestNGReporterLog.error(e.getStackTrace()); + CustomTestNGReporterLog.error(e.getMessage()); } return retBuf.toString(); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertIda.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertIda.java index 0349654d09c..8d5908c326b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertIda.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertIda.java @@ -61,7 +61,7 @@ public boolean jsonComparison(Object expectedResponseBody, Object actualResponse } } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } logger.info("equal"); return true; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertKernel.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertKernel.java index cbacb1bd42a..eed2a52535b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertKernel.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/AssertKernel.java @@ -105,7 +105,7 @@ public boolean jsonComparison(Object expectedResponseBody, Object actualResponse } } catch (IOException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } logger.info("equal"); return true; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java index 4db82ea7498..5699172581d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java @@ -62,7 +62,7 @@ public void run() { } } } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } finally { AdminTestUtil.closeBufferedReader(bufferedReader); AdminTestUtil.closeFileReader(fileReader); @@ -86,7 +86,7 @@ public void run() { try { Thread.sleep(60000); } catch (InterruptedException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); Thread.currentThread().interrupt(); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java index a9ef75c8ba1..74ea4aa0ca2 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java @@ -43,7 +43,7 @@ public void run() { WebSocket ws = HttpClient.newHttpClient().newWebSocketBuilder() .buildAsync(URI.create(a1 + a2 + a3), new WebSocketClient()).join(); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 1f8ad95dcea..2194916db46 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -198,7 +198,7 @@ public static String generatePulicKey() { final KeyPair keypair = keyGenerator.generateKeyPair(); publicKey = java.util.Base64.getEncoder().encodeToString(keypair.getPublic().getEncoded()); } catch (NoSuchAlgorithmException e) { - LOGGER.error(e.getStackTrace()); + LOGGER.error(e.getMessage()); } return publicKey; } @@ -225,7 +225,7 @@ public static String generatePublicKeyForMimoto() { throw e; } } catch (Exception e) { - LOGGER.error(e.getStackTrace()); + LOGGER.error(e.getMessage()); } return vcString; } @@ -241,7 +241,7 @@ public static String generateJWKPublicKey() { return jwk.toJSONString(); } catch (NoSuchAlgorithmException e) { - LOGGER.error(e.getStackTrace()); + LOGGER.error(e.getMessage()); return null; } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java index 42d27cc0a2a..845f78ead76 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java @@ -144,7 +144,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad try { res = resJsonObject.get("response").toString(); } catch (JSONException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java index fe7f0d36c50..df9282c1484 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java @@ -110,7 +110,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { encryptedIdentityReq = getBioDataUtil().constractBioIdentityRequest(identityRequest, getResourcePath() + properties.getProperty("bioValueEncryptionTemplate"), testCaseName, isInternal); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } Map bioAuthTempMap = (isInternal) @@ -145,7 +145,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { try { res = resJsonObject.get("response").toString(); } catch (JSONException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } Reporter.log("Request for decrypting kyc data"); response = postWithBodyAcceptTextPlainAndCookie(EncryptionDecrptionUtil.getEncryptUtilBaseUrl()+properties.getProperty("decryptkycdataurl"), diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java index 7893ece7829..14bf45dfc4d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java @@ -168,7 +168,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java index 2f85dfa5be9..b25f65bcd2e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java @@ -145,7 +145,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad encryptedIdentityReq = bioDataUtil.constractBioIdentityRequest(identyEnryptRequest, getResourcePath() + properties.getProperty("bioValueEncryptionTemplate"), testCaseName, false); } catch (Exception e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } if (Arrays.asList(testCaseDTO.getTestCaseName().split("_")).contains("MultiFactorAuth")) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java index 0dd10e8b5e1..82571f07824 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java @@ -165,7 +165,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { try { resp = resJsonObject.get("response").toString(); } catch (JSONException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } Reporter.log("Request for decrypting kyc data"); response = postWithBodyAcceptTextPlainAndCookie(EncryptionDecrptionUtil.getEncryptUtilBaseUrl()+properties.getProperty("decryptkycdataurl"), diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java index fcfd3549d5f..ce331298b03 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java @@ -208,7 +208,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad try { resp = resJsonObject.get("response").toString(); } catch (JSONException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java index 07ab7d7fa8a..b9a507fd13c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java @@ -117,7 +117,7 @@ public void test(TestCaseDTO testCaseDTO) try { Thread.sleep(Long.parseLong(properties.getProperty("uinGenDelayTime"))); } catch (NumberFormatException | InterruptedException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); Thread.currentThread().interrupt(); } } else { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java index c90f13cef45..ed727faf7b7 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java @@ -124,7 +124,7 @@ else if(testCaseName.contains("ESignet_WalletBinding")) { + " mili secs to test expire otp case in RESIDENT Service"); Thread.sleep(Long.parseLong(properties.getProperty("expireOtpTime"))); } catch (NumberFormatException | InterruptedException e) { - logger.error(e.getStackTrace()); + logger.error(e.getMessage()); Thread.currentThread().interrupt(); } } From 880487ceb1648b40d82bcd8e6677b2873ef53208 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 3 Aug 2023 17:04:50 +0530 Subject: [PATCH 010/204] MOSIP-28653 --- .../resources/resident/GenerateVID/createGenerateVID.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index d29317de870..d8bfe54a3ad 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -1878,6 +1878,12 @@ GenerateVID: } ], "sendOtpResp":{ + "errors": [ + { + "errorCode": "IDA-OTA-008", + "message": "$IGNORE$" + } + ], "sendOtpResTemplate":"resident/error" } }' From a12a68ca0e0a3b37ff1614e554bcaee7fe583500 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Fri, 4 Aug 2023 12:14:20 +0530 Subject: [PATCH 011/204] handles esignet bio auth related exception --- .../demo/service/controller/Decrypt.java | 4 +--- .../demo/service/controller/Encrypt.java | 18 ++++++++---------- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Decrypt.java b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Decrypt.java index 05383777f5b..ada38291029 100644 --- a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Decrypt.java +++ b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Decrypt.java @@ -441,9 +441,7 @@ public String decryptEkycData( @RequestParam(name = "keyFileNameByPartnerName", required = false) boolean keyFileNameByPartnerName, @RequestParam(name = "certsDir", required = false) String certsDir, @RequestParam(name = "moduleName", required = false) String moduleName - ) throws CertificateException, IOException, - NoSuchAlgorithmException, UnrecoverableEntryException, KeyStoreException, OperatorCreationException, - InvalidKeyException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { + ) throws Exception { String identity = requestData.get("identity"); PrivateKeyEntry ekycKey = keyMgrUtil.getKeyEntry(keyMgrUtil.getKeysDirPath(certsDir, moduleName), PartnerTypes.EKYC, partnerName, keyFileNameByPartnerName); diff --git a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java index 4674b0c6448..9c75bd94aa7 100644 --- a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java +++ b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/Encrypt.java @@ -188,9 +188,7 @@ public SplittedEncryptedData encryptBiometrics(@RequestBody String bioValue, @RequestParam(name = "timestamp", required = false) @Nullable String timestamp, @RequestParam(name = "transactionId", required = false) @Nullable String transactionId, @RequestParam(name = "isInternal", required = false) @Nullable boolean isInternal) - throws KeyManagementException, NoSuchAlgorithmException, IOException, JSONException, InvalidKeyException, - NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, - InvalidKeySpecException { + throws Exception { RestTemplate restTemplate = createRestTemplate(); byte[] xorBytes = BytesUtil.getXOR(timestamp, transactionId); @@ -256,7 +254,7 @@ public static RequestWrapper createRequest(T t) { } @PostMapping(path = "/splitEncryptedData", produces = MediaType.APPLICATION_JSON_VALUE) - public SplittedEncryptedData splitEncryptedData(@RequestBody String data) { + public SplittedEncryptedData splitEncryptedData(@RequestBody String data) throws Exception { boolean encryptedDataHasVersion = env.getProperty("encryptedDataHasVersion", boolean.class, false); byte[] dataBytes = CryptoUtil.decodeURLSafeBase64(data); byte[][] splits = splitAtFirstOccurance(dataBytes, keySplitter.getBytes()); @@ -264,14 +262,14 @@ public SplittedEncryptedData splitEncryptedData(@RequestBody String data) { byte[] sessionKey; byte[] thumbPrint; - if(encryptedDataHasVersion) { - thumbPrint = Arrays.copyOfRange(thumbPrintAndSessionKey, 6, 38);//Skip the 6 bytes version and take 32 bytes - sessionKey = Arrays.copyOfRange(thumbPrintAndSessionKey, 38, thumbPrintAndSessionKey.length); + if (thumbPrintAndSessionKey.length >= 288) { + thumbPrint = Arrays.copyOfRange(thumbPrintAndSessionKey, thumbPrintAndSessionKey.length - 288, + thumbPrintAndSessionKey.length - 256);// Skip the 6 bytes version and take 32 bytes + sessionKey = Arrays.copyOfRange(thumbPrintAndSessionKey, thumbPrintAndSessionKey.length - 256, + thumbPrintAndSessionKey.length); } else { - thumbPrint = Arrays.copyOfRange(thumbPrintAndSessionKey, 0, 32); - sessionKey = Arrays.copyOfRange(thumbPrintAndSessionKey, 32, thumbPrintAndSessionKey.length); - } + throw new Exception("Invalid Encrypted Session Key"); } byte[] encryptedData = splits[1]; return new SplittedEncryptedData(CryptoUtil.encodeToURLSafeBase64(sessionKey), CryptoUtil.encodeToURLSafeBase64(encryptedData), digestAsPlainText(thumbPrint)); From f4d416a39bfaa08c8c8ef3042f591dd75304eb5d Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Fri, 4 Aug 2023 13:17:49 +0530 Subject: [PATCH 012/204] Update push_trigger.yml To build Signed-off-by: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> --- .github/workflows/push_trigger.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/push_trigger.yml b/.github/workflows/push_trigger.yml index 13c11cb41f4..5a65b60010a 100644 --- a/.github/workflows/push_trigger.yml +++ b/.github/workflows/push_trigger.yml @@ -9,6 +9,7 @@ on: - develop - MOSIP-* - "0.9" + - 115_compatible_Test jobs: build-authentication-demo-service: From 0b1ca2e5908cfbc09ee8c702402b3423b75c9de6 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 4 Aug 2023 15:29:33 +0530 Subject: [PATCH 013/204] MOSIP-28808 --- .../authentication/fw/util/RestClient.java | 1121 +++++++++++++---- .../apirig/kernel/util/CommonLibrary.java | 468 +++++-- .../apirig/kernel/util/ConfigManager.java | 4 + 3 files changed, 1186 insertions(+), 407 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java index 08a8535d5d6..7410dfb1235 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java @@ -11,6 +11,7 @@ import org.apache.log4j.Logger; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.restassured.RestAssured; import io.restassured.config.HttpClientConfig; import io.restassured.config.RestAssuredConfig; @@ -45,9 +46,16 @@ public class RestClient { public static Response postRequestWithAuthHeader(String url, Object body, String contentHeader, String acceptHeader, String authHeaderName, String authHeaderValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) - .body(body).contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log() - .all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then() + .log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract() + .response(); + } RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -64,8 +72,15 @@ public static Response postRequestWithAuthHeader(String url, Object body, String */ public static Response postRequest(String url, Object body, String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -76,35 +91,61 @@ public static Response postWithFormPathParamAndFile(String url, Map pathParams, File file, String fileKeyName, String contentHeader, String cookie) { + + public static Response postWithParamsAndFile(String url, Map pathParams, File file, + String fileKeyName, String contentHeader, String cookie) { RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) - .pathParams(pathParams).contentType(contentHeader).expect().when().post(url) - .then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().extract() + .response(); + } + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } - - public static Response postWithParamsAndFile(String url, Map pathParams, File file, String fileKeyName, String contentHeader, String cookieValue, String idTokenName, String idTokenValue) { + + public static Response postWithParamsAndFile(String url, Map pathParams, File file, + String fileKeyName, String contentHeader, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(GlobalConstants.AUTHORIZATION, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); - Response postResponse = given().cookies(tokens).relaxedHTTPSValidation().multiPart(fileKeyName, file) - .pathParams(pathParams).contentType(contentHeader).expect().when().post(url) - .then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookies(tokens).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookies(tokens).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().extract() + .response(); + } + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; @@ -114,16 +155,27 @@ public static Response postWithFormDataAndFile(String url, Map f String contentHeader, String cookie) { RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) - .multiPart("files", new File(filePath)).multiPart("tableName", formParams.get("tableName")) - .multiPart(GlobalConstants.OPERATION, formParams.get(GlobalConstants.OPERATION)).multiPart("category", formParams.get("category")) - .expect().when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) + .multiPart("files", new File(filePath)).multiPart("tableName", formParams.get("tableName")) + .multiPart(GlobalConstants.OPERATION, formParams.get(GlobalConstants.OPERATION)) + .multiPart("category", formParams.get("category")).expect().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) + .multiPart("files", new File(filePath)).multiPart("tableName", formParams.get("tableName")) + .multiPart(GlobalConstants.OPERATION, formParams.get(GlobalConstants.OPERATION)) + .multiPart("category", formParams.get("category")).expect().when().post(url).then().extract() + .response(); + } + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } - public static Response postWithMultipartFormDataAndFile(String url, Map formParams, + public static Response postWithMultipartFormDataAndFile(String url, Map formParams, String contentHeader, String cookie) { RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); @@ -133,8 +185,12 @@ public static Response postWithMultipartFormDataAndFile(String url, Map entry : formParams.entrySet()) { requestSpecification.multiPart(entry.getKey(), entry.getValue()); } - - Response postResponse = requestSpecification.expect().when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = requestSpecification.expect().when().post(url).then().log().all().extract().response(); + } else { + postResponse = requestSpecification.expect().when().post(url).then().extract().response(); + } // log then response RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); @@ -142,8 +198,8 @@ public static Response postWithMultipartFormDataAndFile(String url, Map formParams, - File[] filePath, String contentHeader, String cookie) { + public static Response postWithFormDataAndMultipleFile(String url, Map formParams, File[] filePath, + String contentHeader, String cookie) { RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); @@ -152,9 +208,18 @@ public static Response postWithFormDataAndMultipleFile(String url, Map queryParams, String contentHeader, String acceptHeader) { + public static Response postRequestWithQueryParamAndBody(String url, Object body, Map queryParams, + String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) - .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - public static Response postRequestWithQueryParamsAndBody(String url, Object body, - Map queryParams, String contentHeader, String acceptHeader) { + public static Response postRequestWithQueryParamsAndBody(String url, Object body, Map queryParams, + String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) - .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -204,9 +290,16 @@ public static Response postRequestWithQueryParamsAndBody(String url, Object body public static Response putRequestWithQueryParamAndBody(String url, Object body, Map queryParams, String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request with query param " + url); - Response puttResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) - .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() - .extract().response(); + Response puttResponse; + if (ConfigManager.IsDebugEnabled()) { + puttResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + puttResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + puttResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + puttResponse.time()); return puttResponse; @@ -223,8 +316,14 @@ public static Response putRequestWithQueryParamAndBody(String url, Object body, */ public static Response getRequest(String url, String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info("RESSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().log().all().when().get(url).then().log() - .all().extract().response(); + Response getResponse; + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().log().all().when().get(url).then().log().all() + .extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().when().get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -241,9 +340,15 @@ public static Response getRequest(String url, String contentHeader, String accep */ public static Response postRequest(String url, File file, String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().multiPart(file) - .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().multiPart(file).contentType(contentHeader) + .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().multiPart(file).contentType(contentHeader) + .accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -260,8 +365,16 @@ public static Response postRequest(String url, File file, String contentHeader, */ public static Response postRequest(String url, String content, String contentHeader, MediaType acceptHeader) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(content).contentType(contentHeader) - .accept(acceptHeader.toString()).log().all().when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(content).contentType(contentHeader) + .accept(acceptHeader.toString()).log().all().when().post(url).then().log().all().extract() + .response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(content).contentType(contentHeader) + .accept(acceptHeader.toString()).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -278,8 +391,15 @@ public static Response postRequest(String url, String content, String contentHea */ public static Response patchRequest(String url, String body, String contentHeader, String acceptHeader) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .accept(acceptHeader).log().all().when().patch(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).log().all().when().patch(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).when().patch(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -288,8 +408,15 @@ public static Response patchRequest(String url, String body, String contentHeade public static String getCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse.getCookie(cookieName); @@ -298,43 +425,73 @@ public static String getCookie(String url, Object body, String contentHeader, St public static Response postRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response postRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookies(tokens).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookies(tokens).accept(acceptHeader).log().all().when().post(url).then().log().all().extract() + .response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookies(tokens).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response deleteRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); - Response deleteResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().delete(url).then().log().all() - .extract().response(); + Response deleteResponse; + if (ConfigManager.IsDebugEnabled()) { + deleteResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().delete(url).then().log() + .all().extract().response(); + } else { + deleteResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().delete(url).then().extract() + .response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } - - public static Response postRequestWithoutCookie(String url, Object body, String contentHeader, String acceptHeader) { + + public static Response postRequestWithoutCookie(String url, Object body, String contentHeader, + String acceptHeader) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -343,9 +500,17 @@ public static Response postRequestWithoutCookie(String url, Object body, String public static Response postRequestWithBearerToken(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) - .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) + .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all() + .when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) + .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).when() + .post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -354,9 +519,16 @@ public static Response postRequestWithBearerToken(String url, Object body, Strin public static Response postRequestWithHeder(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .header(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .header(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .header(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -365,20 +537,36 @@ public static Response postRequestWithHeder(String url, Object body, String cont public static Response postRequestWithMultipleHeaders(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() + .post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response postRequestWithMultipleHeadersAndCookies(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) - .contentType(contentHeader).cookie("XSRF-TOKEN", "7d01b2a8-b89d-41ad-9361-d7f6294021d1").accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).cookie("XSRF-TOKEN", "7d01b2a8-b89d-41ad-9361-d7f6294021d1") + .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).cookie("XSRF-TOKEN", "7d01b2a8-b89d-41ad-9361-d7f6294021d1") + .accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -387,9 +575,16 @@ public static Response postRequestWithMultipleHeadersAndCookies(String url, Obje public static Response postRequestWithMultipleHeadersWithoutCookie(String url, Object body, String contentHeader, String acceptHeader, Map headers) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) - .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -398,9 +593,17 @@ public static Response postRequestWithMultipleHeadersWithoutCookie(String url, O public static Response patchRequestWithMultipleHeaders(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response patchResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .patch(url).then().log().all().extract().response(); + Response patchResponse; + if (ConfigManager.IsDebugEnabled()) { + patchResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() + .patch(url).then().log().all().extract().response(); + } else { + patchResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + patchResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + patchResponse.time()); return patchResponse; @@ -409,23 +612,40 @@ public static Response patchRequestWithMultipleHeaders(String url, Object body, public static Response postRequestWithCookieAndHeader(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String authHeaderName, String authHeaderValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) - .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all() - .when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log() + .all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when() + .post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response postRequestWithCookieAndHeader(String url, Object body, String contentHeader, - String acceptHeader, String cookieName, String cookieValue, String authHeaderName, String authHeaderValue, String idTokenName, String idTokenValue) { + String acceptHeader, String cookieName, String cookieValue, String authHeaderName, String authHeaderValue, + String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) - .body(body).contentType(contentHeader).cookies(tokens).accept(acceptHeader).log().all() - .when().post(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).cookies(tokens).accept(acceptHeader).log().all().when() + .post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).cookies(tokens).accept(acceptHeader).when().post(url).then() + .extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -434,9 +654,17 @@ public static Response postRequestWithCookieAndHeader(String url, Object body, S public static Response patchRequestWithCookieAndHeader(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String authHeaderName, String authHeaderValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) - .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all() - .when().patch(url).then().log().all().extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log() + .all().when().patch(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) + .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when() + .patch(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -445,8 +673,15 @@ public static Response patchRequestWithCookieAndHeader(String url, Object body, public static Response getRequestWithCookie(String url, String contentHeader, String acceptHeader, String urls, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).log() - .all().when().get(url + "?" + urls).then().log().all().extract().response(); + Response getResponse; + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).log().all() + .when().get(url + "?" + urls).then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).when() + .get(url + "?" + urls).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -455,34 +690,55 @@ public static Response getRequestWithCookie(String url, String contentHeader, St public static Response patchRequestWithCookie(String url, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response patchRequestWithCookie(String url, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookies(tokens).accept(acceptHeader).log().all().when().patch(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookies(tokens).accept(acceptHeader).log().all().when().patch(url).then().log().all().extract() + .response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookies(tokens).accept(acceptHeader).when().patch(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response patchRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log().all() - .extract().response(); + Response postResponse; + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -491,42 +747,73 @@ public static Response patchRequestWithCookie(String url, Object body, String co public static Response getRequestWithCookie(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).log() - .all().when().get(url).then().log().all().extract().response(); + Response getResponse; + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).log().all() + .when().get(url).then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).when() + .get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - + public static Response getRequestWithCookie(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().cookies(tokens).log() - .all().when().get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().cookies(tokens).log().all().when().get(url) + .then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().cookies(tokens).when().get(url).then() + .extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - + public static Response getRequestWithBearerToken(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().headers(cookieName, "Bearer " + cookieValue).log() - .all().when().get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().headers(cookieName, "Bearer " + cookieValue) + .log().all().when().get(url).then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().headers(cookieName, "Bearer " + cookieValue) + .when().get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - + public static Response getRequestWithCookieForKeyCloak(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) - .contentType(contentHeader).relaxedHTTPSValidation().accept(acceptHeader).log().all().when() - .get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) + .relaxedHTTPSValidation().accept(acceptHeader).log().all().when().get(url).then().log().all() + .extract().response(); + } else { + getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) + .relaxedHTTPSValidation().accept(acceptHeader).when().get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -535,10 +822,17 @@ public static Response getRequestWithCookieForKeyCloak(String url, String conten public static Response getRequestWithCookieForUin(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation() + .header(new Header("cookie", cookieName + cookieValue)).log().all().when().get(url).then().log() + .all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation() + .header(new Header("cookie", cookieName + cookieValue)).when().get(url).then().extract().response(); + } - Response getResponse = given().config(config).relaxedHTTPSValidation() - .header(new Header("cookie", cookieName + cookieValue)).log().all().when().get(url).then().log().all() - .extract().response(); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -547,9 +841,17 @@ public static Response getRequestWithCookieForUin(String url, String contentHead public static Response postRequestWithCookie(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().contentType(contentHeader) - .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -558,9 +860,17 @@ public static Response postRequestWithCookie(String url, String contentHeader, S public static Response putRequestWithParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .put(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -569,9 +879,17 @@ public static Response putRequestWithParm(String url, Map body, public static Response patchRequestWithParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .patch(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -580,20 +898,38 @@ public static Response patchRequestWithParm(String url, Map body public static Response putWithPathParamsBodyAndCookie(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .put(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() + .put(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response putWithPathParamsBodyAndBearerToken(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) - .contentType(contentHeader).headers(cookieName, "Bearer " + cookieValue).accept(acceptHeader).log().all().when() - .put(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).headers(cookieName, "Bearer " + cookieValue).accept(acceptHeader).log() + .all().when().put(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).headers(cookieName, "Bearer " + cookieValue).accept(acceptHeader).when() + .put(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -602,42 +938,78 @@ public static Response putWithPathParamsBodyAndBearerToken(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() + .post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - - public static Response postWithPathParamsBodyHeadersAndCookie(String url, Map pathParams, String body, - String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { + + public static Response postWithPathParamsBodyHeadersAndCookie(String url, Map pathParams, + String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, + Map headers) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).pathParams(pathParams).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).pathParams(pathParams) + .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log() + .all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).pathParams(pathParams) + .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when() + .post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response postWithQueryParamsBodyAndCookie(String url, Map queryParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().queryParams(queryParams).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(queryParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() + .post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(queryParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - - public static Response postWithBodyAndCookie(String url, Object body, - String contentHeader, String acceptHeader, String cookieName, String cookieValue) { + + public static Response postWithBodyAndCookie(String url, Object body, String contentHeader, String acceptHeader, + String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -646,20 +1018,37 @@ public static Response postWithBodyAndCookie(String url, Object body, public static Response patchWithPathParamsBodyAndCookie(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .patch(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() + .patch(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - + public static Response postRequestWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -668,9 +1057,17 @@ public static Response postRequestWithQueryParm(String url, Map public static Response putRequestWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .put(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -679,57 +1076,99 @@ public static Response putRequestWithQueryParm(String url, Map b public static Response putRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() - .extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } - + public static Response putRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); - Response putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .cookies(tokens).accept(acceptHeader).log().all().when().put(url).then().log().all() - .extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookies(tokens).accept(acceptHeader).log().all().when().put(url).then().log().all().extract() + .response(); + } else { + putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .cookies(tokens).accept(acceptHeader).when().put(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } - public static Response getRequestWithCookieAndPathParm(String url, Map body, - String contentHeader, String acceptHeader, String cookieName, String cookieValue) { + public static Response getRequestWithCookieAndPathParm(String url, Map body, String contentHeader, + String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) - .cookie(cookieName, cookieValue).log().all().when().get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) + .cookie(cookieName, cookieValue).log().all().when().get(url).then().log().all().extract() + .response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) + .cookie(cookieName, cookieValue).when().get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - - public static Response getRequestWithCookieAndPathParm(String url, Map body, - String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { + + public static Response getRequestWithCookieAndPathParm(String url, Map body, String contentHeader, + String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) - .cookies(tokens).log().all().when().get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).log().all() + .when().get(url).then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).when() + .get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - + public static Response getRequestWithCookieAndPathParmForKeyCloak(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) - .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all().when() - .get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) + .relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all().when().get(url).then().log() + .all().extract().response(); + } else { + getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) + .relaxedHTTPSValidation().body(body).accept(acceptHeader).when().get(url).then().extract() + .response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -738,81 +1177,141 @@ public static Response getRequestWithCookieAndPathParmForKeyCloak(String url, Ma public static byte[] getPdf(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - byte[] pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") - .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() - .asByteArray(); + byte[] pdf; + + if (ConfigManager.IsDebugEnabled()) { + pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") + .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() + .asByteArray(); + } else { + pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") + .accept("*/*").cookie(cookieName, cookieValue).when().get(url).then().extract().asByteArray(); + } return pdf; } - + public static byte[] getPdf(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - byte[] pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") - .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract() - .asByteArray(); + byte[] pdf; + + if (ConfigManager.IsDebugEnabled()) { + pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") + .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract().asByteArray(); + } else { + pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") + .accept("*/*").cookies(tokens).when().get(url).then().extract().asByteArray(); + } + return pdf; } - + public static byte[] postWithBodyForPdf(String url, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - byte[] pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() - .asByteArray(); + byte[] pdf; + + if (ConfigManager.IsDebugEnabled()) { + pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept("*/*") + .cookie(cookieName, cookieValue).log().all().when().get(url).then().extract().asByteArray(); + } else { + pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept("*/*") + .cookie(cookieName, cookieValue).when().get(url).then().extract().asByteArray(); + } + return pdf; } - + public static byte[] postWithBodyForPdf(String url, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - byte[] pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) - .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract() - .asByteArray(); + byte[] pdf; + + if (ConfigManager.IsDebugEnabled()) { + pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept("*/*") + .cookies(tokens).log().all().when().get(url).then().extract().asByteArray(); + } else { + pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept("*/*") + .cookies(tokens).when().get(url).then().extract().asByteArray(); + } + return pdf; } - - public static byte[] getPdfWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, - String cookieName, String cookieValue) { + + public static byte[] getPdfWithQueryParm(String url, Map body, String contentHeader, + String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - byte[] pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") - .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() - .asByteArray(); + byte[] pdf; + + if (ConfigManager.IsDebugEnabled()) { + pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") + .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() + .asByteArray(); + } else { + pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") + .accept("*/*").cookie(cookieName, cookieValue).when().get(url).then().extract().asByteArray(); + } + return pdf; } - - public static byte[] getPdfWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, - String cookieName, String cookieValue, String idTokenName, String idTokenValue) { + + public static byte[] getPdfWithQueryParm(String url, Map body, String contentHeader, + String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - byte[] pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") - .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract() - .asByteArray(); + byte[] pdf; + + if (ConfigManager.IsDebugEnabled()) { + pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") + .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract().asByteArray(); + } else { + pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") + .accept("*/*").cookies(tokens).when().get(url).then().extract().asByteArray(); + } + return pdf; } - public static Response getRequestWithCookieAndQueryParm(String url, Map body, - String contentHeader, String acceptHeader, String cookieName, String cookieValue) { + public static Response getRequestWithCookieAndQueryParm(String url, Map body, String contentHeader, + String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) - .cookie(cookieName, cookieValue).log().all().when().get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) + .cookie(cookieName, cookieValue).log().all().when().get(url).then().log().all().extract() + .response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) + .cookie(cookieName, cookieValue).when().get(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - - public static Response getRequestWithQueryParm(String url, Map body, - String contentHeader, String acceptHeader) { + + public static Response getRequestWithQueryParm(String url, Map body, String contentHeader, + String acceptHeader) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) - .log().all().when().get(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).log().all().when().get(url) + .then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).when().get(url).then() + .extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -821,88 +1320,156 @@ public static Response getRequestWithQueryParm(String url, Map b public static Response patchRequestWithCookieAndQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) - .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() - .patch(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() + .all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) + .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); + } RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - - public static Response deleteRequestWithCookieAndPathParm(String url,Map body, String contentHeader, String acceptHeader,String cookieName,String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); - Response deleteResponse= given().config(config).relaxedHTTPSValidation().pathParams(body).cookie(cookieName, cookieValue) - .log().all().when().delete(url).then().log().all().extract().response(); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); - return deleteResponse; - } - - public static Response deleteRequestWithCookieAndPathParm(String url,Map body, String contentHeader, String acceptHeader,String cookieName,String cookieValue, String idTokenName, String idTokenValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); - Map tokens = new HashMap<>(); + public static Response deleteRequestWithCookieAndPathParm(String url, Map body, + String contentHeader, String acceptHeader, String cookieName, String cookieValue) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + Response deleteResponse; + + if (ConfigManager.IsDebugEnabled()) { + deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) + .cookie(cookieName, cookieValue).log().all().when().delete(url).then().log().all().extract() + .response(); + } else { + deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) + .cookie(cookieName, cookieValue).when().delete(url).then().extract().response(); + } + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); + return deleteResponse; + } + + public static Response deleteRequestWithCookieAndPathParm(String url, Map body, + String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, + String idTokenValue) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - Response deleteResponse= given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens) - .log().all().when().delete(url).then().log().all().extract().response(); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); - return deleteResponse; - } - + Response deleteResponse; + + if (ConfigManager.IsDebugEnabled()) { + deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).log() + .all().when().delete(url).then().log().all().extract().response(); + } else { + deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).when() + .delete(url).then().extract().response(); + } + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); + return deleteResponse; + } + public static Response deleteRequest(String url, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); - Response deleteResponse= given().config(config).relaxedHTTPSValidation() - .log().all().when().delete(url).then().log().all().extract().response(); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); - return deleteResponse; - } - - + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + Response deleteResponse; + + if (ConfigManager.IsDebugEnabled()) { + deleteResponse = given().config(config).relaxedHTTPSValidation().log().all().when().delete(url).then().log() + .all().extract().response(); + } else { + deleteResponse = given().config(config).relaxedHTTPSValidation().when().delete(url).then().extract() + .response(); + } + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); + return deleteResponse; + } + public static Response deleteRequestWithCookieAndPathParmForKeyCloak(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); - - Response deleteResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) - .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all().when() - .delete(url).then().log().all().extract().response(); + Response deleteResponse; + + if (ConfigManager.IsDebugEnabled()) { + deleteResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) + .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all() + .when().delete(url).then().log().all().extract().response(); + } else { + deleteResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) + .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).when() + .delete(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } - + public static Response postRequestWithCookieAndOnlyPathParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) - .cookie(cookieName, cookieValue).log().all().when().post(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) + .cookie(cookieName, cookieValue).log().all().when().post(url).then().log().all().extract() + .response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) + .cookie(cookieName, cookieValue).when().post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - + public static Response postRequestWithCookieAndOnlyPathParm(String url, Map body, - String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { + String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, + String idTokenValue) { Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); - Response getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) - .cookies(tokens).log().all().when().post(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).log().all() + .when().post(url).then().log().all().extract().response(); + } else { + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).when() + .post(url).then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - + public static Response postRequestWithQueryParamBodyAndCookie(String url, Object body, Map queryParams, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); - Response postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) - .cookie(cookieName, cookieValue).contentType(contentHeader).accept(acceptHeader).log().all().when() - .post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .cookie(cookieName, cookieValue).contentType(contentHeader).accept(acceptHeader).log().all().when() + .post(url).then().log().all().extract().response(); + } else { + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) + .cookie(cookieName, cookieValue).contentType(contentHeader).accept(acceptHeader).when().post(url) + .then().extract().response(); + } + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index 39c0b4e0a19..e17a96c24c1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -47,6 +47,7 @@ public class CommonLibrary extends BaseTestCase { private static Logger logger = Logger.getLogger(CommonLibrary.class); private ApplicationLibrary applicationLibrary = new ApplicationLibrary(); + public void checkResponseUTCTime(Response response) { logger.info(response.asString()); JSONObject responseJson = null; @@ -57,9 +58,10 @@ public void checkResponseUTCTime(Response response) { logger.info(e1.getMessage()); return; } - if(responseJson!=null && responseJson.containsKey("responsetime")) + if (responseJson != null && responseJson.containsKey("responsetime")) responseTime = response.jsonPath().get("responsetime").toString(); - else return; + else + return; String cuurentUTC = (String) getCurrentUTCTime(); SimpleDateFormat sdf = new SimpleDateFormat("mm"); try { @@ -113,14 +115,14 @@ public List getFoldersFilesNameList(String folderRelativePath, boolean i public String getResourcePath() { return MosipTestRunner.getGlobalResourcePath() + "/"; } - + public String getResourcePathForKernel() { return MosipTestRunner.getResourcePath() + "/"; } public JSONObject readJsonData(String path, boolean isRelative) { logger.info("path : " + path); - if(isRelative) + if (isRelative) path = getResourcePath() + path; logger.info("Relativepath : " + path); FileInputStream inputStream = null; @@ -131,13 +133,12 @@ public JSONObject readJsonData(String path, boolean isRelative) { inputStream = new FileInputStream(fileToRead); jsonData = (JSONObject) new JSONParser().parse(new InputStreamReader(inputStream, StandardCharsets.UTF_8)); } catch (FileNotFoundException e) { - logger.info("error while reading the file : " + e.getLocalizedMessage() ); + logger.info("error while reading the file : " + e.getLocalizedMessage()); logger.error(e.getMessage()); logger.info("File Not Found at the given path"); - } - catch (IOException | ParseException | NullPointerException e) { + } catch (IOException | ParseException | NullPointerException e) { logger.info(e.getMessage()); - }finally { + } finally { AdminTestUtil.closeInputStream(inputStream); } return jsonData; @@ -148,8 +149,10 @@ public Map readProperty(String propertyFileName) { FileInputStream inputStream = null; Map mapProp = null; try { - logger.info("propertyFileName: " + propertyFileName + "Path :" + getResourcePathForKernel() + "config/" + propertyFileName + ".properties"); - logger.info("propertyFileName: " + propertyFileName + "Path :" + getResourcePathForKernel() + "config/" + propertyFileName + ".properties"); + logger.info("propertyFileName: " + propertyFileName + "Path :" + getResourcePathForKernel() + "config/" + + propertyFileName + ".properties"); + logger.info("propertyFileName: " + propertyFileName + "Path :" + getResourcePathForKernel() + "config/" + + propertyFileName + ".properties"); File propertyFile = new File(getResourcePathForKernel() + "config/" + propertyFileName + ".properties"); inputStream = new FileInputStream(propertyFile); prop.load(inputStream); @@ -158,7 +161,7 @@ public Map readProperty(String propertyFileName) { } catch (IOException e) { logger.info("Error occrued while reading propertyFileName " + propertyFileName + e.getMessage()); logger.info(e.getMessage()); - }finally { + } finally { AdminTestUtil.closeInputStream(inputStream); } @@ -195,69 +198,64 @@ public void responseAuthValidation(Response response) { } } } - - public boolean jsonComparator(String requestJson, String responseJson) throws AdminTestException - { + + public boolean jsonComparator(String requestJson, String responseJson) throws AdminTestException { try { JSONAssert.assertEquals(requestJson, responseJson, false); return true; - } catch (JSONException | AssertionError e) { + } catch (JSONException | AssertionError e) { logger.info("EXPECTED AND ACTUAL DATA MISMATCH"); logger.info("MISMATCH DETAILS:"); logger.info(e.getMessage()); - logger.info("Obtained ACTUAL RESPONSE is:== "+responseJson); + logger.info("Obtained ACTUAL RESPONSE is:== " + responseJson); throw new AdminTestException("Failed at output validation"); } } + public boolean isValidToken(String cookie) { - + logger.info("========= Revalidating the token ========="); - Response response = applicationLibrary.getWithoutParams("/v1/authmanager/authorize/admin/validateToken", cookie); - JSONObject responseJson =null; + Response response = applicationLibrary.getWithoutParams("/v1/authmanager/authorize/admin/validateToken", + cookie); + JSONObject responseJson = null; try { - responseJson = (JSONObject) ((JSONObject) new JSONParser().parse(response.asString())) - .get("response"); + responseJson = (JSONObject) ((JSONObject) new JSONParser().parse(response.asString())).get("response"); } catch (ParseException | NullPointerException e) { logger.info(e.getMessage()); } - if (responseJson!=null && responseJson.get("errors")==null) - { + if (responseJson != null && responseJson.get("errors") == null) { logger.info("========= Valid Token ========="); return true; - } - else - { - + } else { + logger.info("========= InValid Token ========="); return false; } } - - - public String removeJsonElement(String readFilePath,ArrayList eleToRemove) throws ParseException { - String jsnString = null; - String val = null; - - try { - String yourActualJSONString = new String(Files.readAllBytes(Paths.get(readFilePath)), StandardCharsets.UTF_8); - DocumentContext jsonContext = JsonPath.parse(yourActualJSONString); - - for (int i = 0; i < eleToRemove.size(); i++) - { - val=eleToRemove.get(i); - jsonContext.delete(val); - jsnString = jsonContext.jsonString(); - } - - - } catch (IOException e) { - logger.error(e.getMessage()); + + public String removeJsonElement(String readFilePath, ArrayList eleToRemove) throws ParseException { + String jsnString = null; + String val = null; + + try { + String yourActualJSONString = new String(Files.readAllBytes(Paths.get(readFilePath)), + StandardCharsets.UTF_8); + DocumentContext jsonContext = JsonPath.parse(yourActualJSONString); + + for (int i = 0; i < eleToRemove.size(); i++) { + val = eleToRemove.get(i); + jsonContext.delete(val); + jsnString = jsonContext.jsonString(); } - return jsnString; - + + } catch (IOException e) { + logger.error(e.getMessage()); } + return jsnString; + + } public void responseLogger(Response response) { int statusCode = response.statusCode(); @@ -271,8 +269,16 @@ public void responseLogger(Response response) { public Response postWithoutJson(String url, String contentHeader, String acceptHeader, String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) - .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) + .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) + .accept(acceptHeader).when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -280,8 +286,16 @@ public Response postWithoutJson(String url, String contentHeader, String acceptH public Response postWithJson(String url, Object body, String contentHeader, String acceptHeader) { logger.info("REST:ASSURED:Sending post request to" + url); - Response postResponse = given().relaxedHTTPSValidation().body(body).contentType(contentHeader) - .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().relaxedHTTPSValidation().body(body).contentType(contentHeader).accept(acceptHeader) + .log().all().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().relaxedHTTPSValidation().body(body).contentType(contentHeader).accept(acceptHeader) + .when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -290,34 +304,58 @@ public Response postWithJson(String url, Object body, String contentHeader, Stri public Response postWithJson(String url, Object body, String contentHeader, String acceptHeader, String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) - .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + // log then response logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - public Response postWithPathParams(String url, Object body, Map pathParams, - String contentHeader, String acceptHeader, String cookie) { + public Response postWithPathParams(String url, Object body, Map pathParams, String contentHeader, + String acceptHeader, String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .body(body).contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log() - .all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } - - public Response postWithOnlyPathParams(String url, Map pathParams, - String contentHeader, String acceptHeader, String cookie) { + + public Response postWithOnlyPathParams(String url, Map pathParams, String contentHeader, + String acceptHeader, String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log() - .all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -326,8 +364,16 @@ public Response postWithOnlyPathParams(String url, Map pathPara public Response postWithOnlyFile(String url, File file, String fileKeyName, String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) - .expect().when().post(url).then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .expect().when().post(url).then().log().all().extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .expect().when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; @@ -337,22 +383,39 @@ public Response postWithFile(String url, Object body, File file, String fileKeyN String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) - .body(body).contentType(contentHeader).expect().when().post(url).then().log().all().extract() - .response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .body(body).contentType(contentHeader).expect().when().post(url).then().log().all().extract() + .response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .body(body).contentType(contentHeader).expect().when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } - public Response postWithFileFormParams(String url, Map formParams, File file, - String fileKeyName, String contentHeader, String cookie) { + public Response postWithFileFormParams(String url, Map formParams, File file, String fileKeyName, + String contentHeader, String cookie) { logger.info("REST:ASSURED:Sending post request to" + url); logger.info("Name of the file is" + file.getName()); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) - .formParams(formParams).contentType(contentHeader).expect().when().post(url).then().log().all() - .extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .formParams(formParams).contentType(contentHeader).expect().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) + .formParams(formParams).contentType(contentHeader).expect().when().post(url).then().extract() + .response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; @@ -372,13 +435,21 @@ public Response postWithFilePathParamsFormParams(String url, Map return postResponse; } - public Response postWithQueryParams(String url, Map queryparams, Object body, - String contentHeader, String acceptHeader, String cookie) { + public Response postWithQueryParams(String url, Map queryparams, Object body, String contentHeader, + String acceptHeader, String cookie) { logger.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) - .queryParams(queryparams).contentType(contentHeader).accept(acceptHeader).log().all().when().post(url) - .then().log().all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).queryParams(queryparams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() + .extract().response(); + } else { + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).queryParams(queryparams) + .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -387,9 +458,18 @@ public Response postWithQueryParams(String url, Map queryparams, public Response postWithMultiHeaders(String endpoint, Object body, Map headers, String contentHeader, String cookie) { Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response postResponse = given().cookie(builder.build()).headers(headers).relaxedHTTPSValidation() - .body("\"" + body + "\"").contentType(contentHeader).log().all().when().post(endpoint).then().log() - .all().extract().response(); + Response postResponse; + + if (ConfigManager.IsDebugEnabled()) { + postResponse = given().cookie(builder.build()).headers(headers).relaxedHTTPSValidation() + .body("\"" + body + "\"").contentType(contentHeader).log().all().when().post(endpoint).then().log() + .all().extract().response(); + } else { + postResponse = given().cookie(builder.build()).headers(headers).relaxedHTTPSValidation() + .body("\"" + body + "\"").contentType(contentHeader).when().post(endpoint).then().extract() + .response(); + } + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; @@ -423,9 +503,16 @@ public Response postRequestEmailNotification(String serviceUri, JSONObject jsonS public Response patchRequest(String url, Object body, String contentHeader, String acceptHeader, String cookie) { logger.info("REST-ASSURED: Sending a Patch request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) - .contentType(contentHeader).accept(acceptHeader).log().all().when().patch(url).then().log().all() - .extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).log().all().when().patch(url).then().log().all().extract().response(); + } else { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).when().patch(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } @@ -433,7 +520,14 @@ public Response patchRequest(String url, Object body, String contentHeader, Stri public Response getWithoutParams(String url, String cookie) { logger.info("REST-ASSURED: Sending a Get request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().log().all().when().get(url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().log().all().when().get(url); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().when().get(url); + } + responseLogger(getResponse); logger.info("REST-ASSURED: the response Time is: " + getResponse.time()); return getResponse; @@ -443,8 +537,16 @@ public Response getWithPathParam(String url, Map patharams, Stri logger.info("REST-ASSURED: Sending a GET request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(patharams).log() - .all().when().get(url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(patharams).log().all() + .when().get(url); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(patharams).when() + .get(url); + } + responseLogger(getResponse); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -454,8 +556,16 @@ public Response getWithQueryParam(String url, Map queryParams, S logger.info("REST-ASSURED: Sending a GET request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log() - .all().when().get(url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log().all() + .when().get(url); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).when() + .get(url); + } + responseLogger(getResponse); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -465,20 +575,35 @@ public Response getWithQueryParamList(String url, Map> quer logger.info("REST-ASSURED: Sending a GET request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log() - .all().when().get(url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log().all() + .when().get(url); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).when() + .get(url); + } + responseLogger(getResponse); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } - public Response getWithPathQueryParam(String url, Map pathParams, - Map queryParams, String cookie) { + public Response getWithPathQueryParam(String url, Map pathParams, Map queryParams, + String cookie) { logger.info("REST-ASSURED: Sending a GET request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .queryParams(queryParams).log().all().when().get(url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .queryParams(queryParams).log().all().when().get(url); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .queryParams(queryParams).when().get(url); + } responseLogger(getResponse); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -489,8 +614,16 @@ public Response getWithPathParamQueryParamList(String url, Map p logger.info("REST-ASSURED: Sending a GET request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .queryParams(queryParams).log().all().when().get(url); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .queryParams(queryParams).log().all().when().get(url); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .queryParams(queryParams).when().get(url); + } + responseLogger(getResponse); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; @@ -499,8 +632,16 @@ public Response getWithPathParamQueryParamList(String url, Map p public Response putWithoutData(String url, String contentHeader, String acceptHeader, String cookie) { logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) - .accept(acceptHeader).log().all().when().put(url).then().log().all().extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) + .accept(acceptHeader).log().all().when().put(url).then().log().all().extract().response(); + } else { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) + .accept(acceptHeader).when().put(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; @@ -509,9 +650,16 @@ public Response putWithoutData(String url, String contentHeader, String acceptHe public Response putWithJson(String url, Object body, String contentHeader, String acceptHeader, String cookie) { logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) - .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() - .extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).log().all().when().put(url).then().log().all().extract().response(); + } else { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).contentType(contentHeader) + .accept(acceptHeader).when().put(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; @@ -521,9 +669,17 @@ public Response putWithPathParams(String url, Map pathParams, St String acceptHeader, String cookie) { logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() - .extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; @@ -533,21 +689,37 @@ public Response putWithQueryParams(String url, Map queryParams, String acceptHeader, String cookie) { logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams) - .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() - .extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams) + .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } - public Response putWithPathParamsBody(String url, Map pathParams, Object body, - String contentHeader, String acceptHeader, String cookie) { + public Response putWithPathParamsBody(String url, Map pathParams, Object body, String contentHeader, + String acceptHeader, String cookie) { logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .body(body).contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log() - .all().extract().response(); + Response putResponse; + + if (ConfigManager.IsDebugEnabled()) { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() + .extract().response(); + } else { + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) + .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; @@ -556,41 +728,69 @@ public Response putWithPathParamsBody(String url, Map pathParams public Response deleteWithPathParams(String url, Map pathParams, String cookie) { logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).log() - .all().when().delete(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).log().all() + .when().delete(url).then().log().all().extract().response(); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).when() + .delete(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; } - public Response deleteWithQueryParams(String url, Map queryParams, String cookie) { logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log() - .all().when().delete(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log().all() + .when().delete(url).then().log().all().extract().response(); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).when() + .delete(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; } - public Response deleteWithPathQueryParams(String url, Map pathParams, Map queryParams, String cookie) { logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) - .queryParams(queryParams).log().all().when().delete(url).then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .queryParams(queryParams).log().all().when().delete(url).then().log().all().extract().response(); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) + .queryParams(queryParams).when().delete(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; } - public Response getConfigProperties(String url) { logger.info("REST-ASSURED: Sending a GET request to " + url); - Response getResponse = given().relaxedHTTPSValidation().log().all().when().get(url).then().log().all().extract() - .response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().relaxedHTTPSValidation().log().all().when().get(url).then().log().all().extract() + .response(); + } else { + getResponse = given().relaxedHTTPSValidation().when().get(url).then().extract().response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } @@ -598,8 +798,16 @@ public Response getConfigProperties(String url) { public Response deleteWithoutParams(String url, String cookie) { logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); - Response getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().log().all().when().delete(url) - .then().log().all().extract().response(); + Response getResponse; + + if (ConfigManager.IsDebugEnabled()) { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().log().all().when().delete(url).then() + .log().all().extract().response(); + } else { + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().when().delete(url).then().extract() + .response(); + } + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index aed5b974369..4c5382df0bf 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -377,6 +377,10 @@ public static boolean isInTobeSkippedList(String stringToFind) { public static Boolean IseSignetDeployed() { return esignet_deployed.equalsIgnoreCase("yes"); } + + public static Boolean IsDebugEnabled() { + return enableDebug.equalsIgnoreCase("yes"); + } public static String getAuthDemoServicePort() { return authDemoServicePort; From c0786b9ab6177f043f450274f3ae925c39512699 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 7 Aug 2023 12:16:54 +0530 Subject: [PATCH 014/204] MOSIP-27327 --- .../mosip/testrig/apirig/kernel/util/ConfigManager.java | 9 +++++++++ .../src/main/resources/config/Kernel.properties | 3 ++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index e2777f197ec..b318dd9e886 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -20,6 +20,7 @@ public class ConfigManager { private static String MOSIP_PMS_CLIENT_SECRET = "mosip_pms_client_secret"; private static String MOSIP_PMS_CLIENT_ID = "mosip_pms_client_id"; private static String MOSIP_PMS_APP_ID = "mosip_pms_app_id"; + private static String MOSIP_PARTNER_CLIENT_ID = "mosip_partner_client_id"; private static String MOSIP_RESIDENT_CLIENT_SECRET = "mosip_resident_client_secret"; private static String MOSIP_RESIDENT_CLIENT_ID = "mosip_resident_client_id"; @@ -123,6 +124,7 @@ public class ConfigManager { private static String pms_client_secret; private static String pms_client_id; private static String pms_app_id; + private static String partner_client_id; private static String resident_client_secret; private static String resident_client_id; @@ -229,6 +231,8 @@ public static void init() { pms_client_secret = getValueForKey(MOSIP_PMS_CLIENT_SECRET); pms_client_id = getValueForKey(MOSIP_PMS_CLIENT_ID); + partner_client_id = getValueForKey(MOSIP_PARTNER_CLIENT_ID); + pms_app_id = getValueForKey(MOSIP_PMS_APP_ID); resident_client_secret = getValueForKey(MOSIP_RESIDENT_CLIENT_SECRET); resident_client_id = getValueForKey(MOSIP_RESIDENT_CLIENT_ID); @@ -462,6 +466,11 @@ public static String getPmsClientSecret() { public static String getPmsClientId() { return pms_client_id; } + + + public static String getPartnerClientId() { + return partner_client_id; + } public static String getPmsAppId() { return pms_app_id; diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index ff344848108..6b3b697b8e5 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -106,7 +106,8 @@ mosip_pms_app_id=partner partner_password=mosip123 partner_userName=111997 partner_user_password=mosip123 -mosip_pms_client_id=mosip-partner-client +mosip_pms_client_id=mosip-pms-client +mosip_partner_client_id=mosip-partner-client mosip_pms_client_secret=abc123 policytest_password=mosip123 policytest_userName=111998 From b5fb91c58202703a564147fca1b327440a9b88c7 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 7 Aug 2023 12:21:55 +0530 Subject: [PATCH 015/204] MOSIP-27327 --- .../testrig/apirig/kernel/util/KernelAuthentication.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java index b50e923b698..f571339bb35 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java @@ -250,10 +250,17 @@ public String getAuthForzoneMap() { public String getAuthForPartner() { JSONObject request=new JSONObject(); + request.put(GlobalConstants.APPID, ConfigManager.getPmsAppId()); request.put(GlobalConstants.PASSWORD, partner_password); request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule +"-"+partner_userName); JSONObject actualInternalrequest = getRequestJson(authInternalRequest); + if (BaseTestCase.isTargetEnvLTS()) { + request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); + } + else { + request.put(GlobalConstants.CLIENTID, ConfigManager.getPartnerClientId()); + } request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPmsClientSecret()); actualInternalrequest.put(GlobalConstants.REQUEST, request); From 49014a132ad4e45078c6701908e105f57e59bf6a Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 7 Aug 2023 12:36:24 +0530 Subject: [PATCH 016/204] MOSIP-27327 --- .../apirig/kernel/util/ConfigManager.java | 8 + .../kernel/util/KernelAuthentication.java | 479 +++++++++--------- .../main/resources/config/Kernel.properties | 1 + 3 files changed, 246 insertions(+), 242 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index b318dd9e886..68a5accb6bf 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -18,6 +18,7 @@ public class ConfigManager { private static final Logger LOGGER = Logger.getLogger(ConfigManager.class); private static String MOSIP_PMS_CLIENT_SECRET = "mosip_pms_client_secret"; + private static String MOSIP_PARTNER_CLIENT_SECRET = "mosip_partner_client_secret"; private static String MOSIP_PMS_CLIENT_ID = "mosip_pms_client_id"; private static String MOSIP_PMS_APP_ID = "mosip_pms_app_id"; private static String MOSIP_PARTNER_CLIENT_ID = "mosip_partner_client_id"; @@ -122,6 +123,7 @@ public class ConfigManager { private static String toSkippedList; private static String pms_client_secret; + private static String partner_client_secret; private static String pms_client_id; private static String pms_app_id; private static String partner_client_id; @@ -230,6 +232,7 @@ public static void init() { propsKernel = getproperty(MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); pms_client_secret = getValueForKey(MOSIP_PMS_CLIENT_SECRET); + partner_client_secret = getValueForKey(MOSIP_PARTNER_CLIENT_SECRET); pms_client_id = getValueForKey(MOSIP_PMS_CLIENT_ID); partner_client_id = getValueForKey(MOSIP_PARTNER_CLIENT_ID); @@ -462,6 +465,11 @@ public static Properties init(String abc) { public static String getPmsClientSecret() { return pms_client_secret; } + + + public static String getPartnerClientSecret() { + return partner_client_secret; + } public static String getPmsClientId() { return pms_client_id; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java index f571339bb35..57a07691299 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java @@ -19,175 +19,174 @@ import io.restassured.RestAssured; import io.restassured.response.Response; -public class KernelAuthentication extends BaseTestCase{ - - String folder="kernel"; +public class KernelAuthentication extends BaseTestCase { + + String folder = "kernel"; String cookie; static String dataKey = "response"; - static String errorKey = "errors"; - static Map tokens = new HashMap<>(); - CommonLibrary clib= new CommonLibrary(); + static String errorKey = "errors"; + static Map tokens = new HashMap<>(); + CommonLibrary clib = new CommonLibrary(); public final Map props = clib.readProperty("Kernel"); - - private String admin_password=props.get("admin_password"); - private String admin_userName=props.get("admin_userName"); - - private String partner_password=props.get("partner_user_password"); - private String partner_userName=props.get("partner_userName"); - - private String registrationAdmin_appid=props.get("registrationAdmin_appid"); - private String registrationAdmin_password=props.get("registrationAdmin_password"); - private String registrationAdmin_userName=props.get("registrationAdmin_userName"); - - - private String registrationOfficer_appid=props.get("registrationOfficer_appid"); - private String registrationOfficer_password=props.get("registrationOfficer_password"); - private String registrationOfficer_userName=props.get("registrationOfficer_userName"); - - private String registrationSupervisor_appid=props.get("registrationSupervisor_appid"); - private String registrationSupervisor_password=props.get("registrationSupervisor_password"); - private String registrationSupervisor_userName=props.get("registrationSupervisor_userName"); - - private String zonalAdmin_password=props.get("zonalAdmin_password"); - private String zonalAdmin_userName=props.get("zonalAdmin_userName"); - - private String zonalApprover_password=props.get("zonalApprover_password"); - private String zonalApprover_userName=props.get("zonalApprover_userName"); - + + private String admin_password = props.get("admin_password"); + private String admin_userName = props.get("admin_userName"); + + private String partner_password = props.get("partner_user_password"); + private String partner_userName = props.get("partner_userName"); + + private String registrationAdmin_appid = props.get("registrationAdmin_appid"); + private String registrationAdmin_password = props.get("registrationAdmin_password"); + private String registrationAdmin_userName = props.get("registrationAdmin_userName"); + + private String registrationOfficer_appid = props.get("registrationOfficer_appid"); + private String registrationOfficer_password = props.get("registrationOfficer_password"); + private String registrationOfficer_userName = props.get("registrationOfficer_userName"); + + private String registrationSupervisor_appid = props.get("registrationSupervisor_appid"); + private String registrationSupervisor_password = props.get("registrationSupervisor_password"); + private String registrationSupervisor_userName = props.get("registrationSupervisor_userName"); + + private String zonalAdmin_password = props.get("zonalAdmin_password"); + private String zonalAdmin_userName = props.get("zonalAdmin_userName"); + + private String zonalApprover_password = props.get("zonalApprover_password"); + private String zonalApprover_userName = props.get("zonalApprover_userName"); + private String authenticationEndpoint = props.get("authentication"); private String authenticationInternalEndpoint = props.get("authenticationInternal"); private String sendOtp = props.get(GlobalConstants.SENDOTP); private String useridOTP = props.get("useridOTP"); - private ApplicationLibrary appl=new ApplicationLibrary(); - private String authRequest="config/Authorization/request.json"; - private String authInternalRequest="config/Authorization/internalAuthRequest.json"; - private String preregSendOtp= props.get("preregSendOtp"); - private String preregValidateOtp= props.get("preregValidateOtp"); - private static File ESignetUINCookiesFile = new File(AdminTestUtil.getResourcePath() + "ESignetUINCookiesResponse.txt"); - private static File ESignetVIDCookiesFile = new File(AdminTestUtil.getResourcePath() + "ESignetVIDCookiesResponse.txt"); + private ApplicationLibrary appl = new ApplicationLibrary(); + private String authRequest = "config/Authorization/request.json"; + private String authInternalRequest = "config/Authorization/internalAuthRequest.json"; + private String preregSendOtp = props.get("preregSendOtp"); + private String preregValidateOtp = props.get("preregValidateOtp"); + private static File ESignetUINCookiesFile = new File( + AdminTestUtil.getResourcePath() + "ESignetUINCookiesResponse.txt"); + private static File ESignetVIDCookiesFile = new File( + AdminTestUtil.getResourcePath() + "ESignetVIDCookiesResponse.txt"); public String getTokenByRole(String role) { return getTokenByRole(role, null); } - - public String getTokenByRole(String role, String tokenType) - { + + public String getTokenByRole(String role, String tokenType) { String insensitiveRole = null; - if(role!=null) + if (role != null) insensitiveRole = role.toLowerCase(); - else return ""; - - switch(insensitiveRole) { - + else + return ""; + + switch (insensitiveRole) { + case "individual": - if(!kernelCmnLib.isValidToken(individualCookie)) + if (!kernelCmnLib.isValidToken(individualCookie)) individualCookie = kernelAuthLib.getAuthForIndividual(); return individualCookie; case "ida": - if(!kernelCmnLib.isValidToken(idaCookie)) + if (!kernelCmnLib.isValidToken(idaCookie)) idaCookie = kernelAuthLib.getAuthForIDA(); return idaCookie; case "idrepo": if (BaseTestCase.isTargetEnvLTS()) { - if(!kernelCmnLib.isValidToken(idrepoCookie)) + if (!kernelCmnLib.isValidToken(idrepoCookie)) idrepoCookie = kernelAuthLib.getAuthForIDREPO(); return idrepoCookie; - } - else { - if(!kernelCmnLib.isValidToken(regProCookie)) + } else { + if (!kernelCmnLib.isValidToken(regProCookie)) regProCookie = kernelAuthLib.getAuthForRegProc(); return regProCookie; } case "regproc": - if(!kernelCmnLib.isValidToken(regProcCookie)) + if (!kernelCmnLib.isValidToken(regProcCookie)) regProcCookie = kernelAuthLib.getAuthForRegistrationProcessor(); return regProcCookie; case "regpro": - if(!kernelCmnLib.isValidToken(regProCookie)) + if (!kernelCmnLib.isValidToken(regProCookie)) regProCookie = kernelAuthLib.getAuthForRegProc(); return regProCookie; case "admin": - if(!kernelCmnLib.isValidToken(adminCookie)) + if (!kernelCmnLib.isValidToken(adminCookie)) adminCookie = kernelAuthLib.getAuthForAdmin(); return adminCookie; case "zonalapprover": - if(!kernelCmnLib.isValidToken(zonalApproverCookie)) + if (!kernelCmnLib.isValidToken(zonalApproverCookie)) zonalApproverCookie = kernelAuthLib.getAuthForZonalApprover(); return zonalApproverCookie; case "partner": - if(!kernelCmnLib.isValidToken(partnerCookie)) + if (!kernelCmnLib.isValidToken(partnerCookie)) partnerCookie = kernelAuthLib.getAuthForPartner(); return partnerCookie; case "partnernew": - if(!kernelCmnLib.isValidToken(partnerNewCookie)) + if (!kernelCmnLib.isValidToken(partnerNewCookie)) partnerNewCookie = kernelAuthLib.getAuthForNewPartner(); return partnerNewCookie; case "esignetpartner": - if(!kernelCmnLib.isValidToken(esignetPartnerCookie)) + if (!kernelCmnLib.isValidToken(esignetPartnerCookie)) esignetPartnerCookie = kernelAuthLib.getAuthForNewPartnerEsignet(); return esignetPartnerCookie; case "policytest": - if(!kernelCmnLib.isValidToken(policytestCookie)) + if (!kernelCmnLib.isValidToken(policytestCookie)) policytestCookie = kernelAuthLib.getAuthForPolicytest(); return policytestCookie; case "batch": - if (!kernelCmnLib.isValidToken(batchJobToken)) + if (!kernelCmnLib.isValidToken(batchJobToken)) batchJobToken = kernelAuthLib.getPreRegToken(); return batchJobToken; case "invalid": return "anyRandomString"; case "regAdmin": - if (!kernelCmnLib.isValidToken(regAdminCookie)) + if (!kernelCmnLib.isValidToken(regAdminCookie)) regAdminCookie = kernelAuthLib.getAuthForRegistrationAdmin(); return regAdminCookie; case GlobalConstants.RESIDENT: - if(!kernelCmnLib.isValidToken(residentCookie)) + if (!kernelCmnLib.isValidToken(residentCookie)) residentCookie = kernelAuthLib.getAuthForResident(); return residentCookie; case "residentnew": - if(!kernelCmnLib.isValidToken(residentNewCookie.get(tokenType))) + if (!kernelCmnLib.isValidToken(residentNewCookie.get(tokenType))) residentNewCookie = getAuthFromEsignet(ESignetUINCookiesFile); return residentNewCookie.get(tokenType); case "residentnewvid": - if(!kernelCmnLib.isValidToken(residentNewVidCookie.get(tokenType))) + if (!kernelCmnLib.isValidToken(residentNewVidCookie.get(tokenType))) residentNewVidCookie = getAuthFromEsignet(ESignetVIDCookiesFile); return residentNewVidCookie.get(tokenType); case "residentnewKc": - if(!kernelCmnLib.isValidToken(residentNewCookieKc)) + if (!kernelCmnLib.isValidToken(residentNewCookieKc)) residentNewCookieKc = kernelAuthLib.getAuthForNewResidentKc(); return residentNewCookieKc; case "hotlist": if (BaseTestCase.isTargetEnvLTS()) { - if(!kernelCmnLib.isValidToken(hotlistCookie)) + if (!kernelCmnLib.isValidToken(hotlistCookie)) residentCookie = kernelAuthLib.getAuthForHotlist(); return residentCookie; - }else { - if(!kernelCmnLib.isValidToken(regProCookie)) + } else { + if (!kernelCmnLib.isValidToken(regProCookie)) regProCookie = kernelAuthLib.getAuthForRegProc(); return regProCookie; } case "globaladmin": - if(!kernelCmnLib.isValidToken(zonemapCookie)) + if (!kernelCmnLib.isValidToken(zonemapCookie)) zonemapCookie = kernelAuthLib.getAuthForzoneMap(); return zonemapCookie; case "mobileauth": - if(!kernelCmnLib.isValidToken(mobileAuthCookie)) + if (!kernelCmnLib.isValidToken(mobileAuthCookie)) mobileAuthCookie = kernelAuthLib.getAuthForMobile(); return mobileAuthCookie; case "state": UUID uuid = UUID.randomUUID(); - + String uuidAsString = uuid.toString(); return uuidAsString; default: - if(!kernelCmnLib.isValidToken(adminCookie)) + if (!kernelCmnLib.isValidToken(adminCookie)) adminCookie = kernelAuthLib.getAuthForAdmin(); - return adminCookie; + return adminCookie; } - + } - - + @SuppressWarnings("unchecked") public HashMap getAuthFromEsignet(File fileName) { HashMap tokens = new HashMap<>(); @@ -204,9 +203,9 @@ public HashMap getAuthFromEsignet(File fileName) { } else { logger.error("ESignetCookiesFile File not Found in location:" + fileName.getAbsolutePath()); } - return tokens; + return tokens; } - + @SuppressWarnings("unchecked") public String getAuthForAdmin() { @@ -215,9 +214,9 @@ public String getAuthForAdmin() { JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getAdminAppId()); request.put(GlobalConstants.PASSWORD, admin_password); - - request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule +"-"+ admin_userName); - + + request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule + "-" + admin_userName); + request.put(GlobalConstants.CLIENTID, ConfigManager.getAdminClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getAdminClientSecret()); actualrequest.put(GlobalConstants.REQUEST, request); @@ -226,8 +225,7 @@ public String getAuthForAdmin() { String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - - + @SuppressWarnings("unchecked") public String getAuthForzoneMap() { @@ -245,83 +243,84 @@ public String getAuthForzoneMap() { String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - + @SuppressWarnings({ "unchecked" }) - public String getAuthForPartner() { - - JSONObject request=new JSONObject(); - + public String getAuthForPartner() { + + JSONObject request = new JSONObject(); + request.put(GlobalConstants.APPID, ConfigManager.getPmsAppId()); request.put(GlobalConstants.PASSWORD, partner_password); - request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule +"-"+partner_userName); + request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule + "-" + partner_userName); JSONObject actualInternalrequest = getRequestJson(authInternalRequest); if (BaseTestCase.isTargetEnvLTS()) { request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); - } - else { + request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPmsClientSecret()); + } else { request.put(GlobalConstants.CLIENTID, ConfigManager.getPartnerClientId()); + request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPartnerClientSecret()); } request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); - request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPmsClientSecret()); + actualInternalrequest.put(GlobalConstants.REQUEST, request); - Response reponse=appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); + Response reponse = appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - + @SuppressWarnings({ "unchecked" }) - public String getAuthForNewPartner() { - - JSONObject request=new JSONObject(); + public String getAuthForNewPartner() { + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getPmsAppId()); request.put(GlobalConstants.PASSWORD, partner_password); - request.put(GlobalConstants.USER_NAME, PartnerRegistration.partnerId); + request.put(GlobalConstants.USER_NAME, PartnerRegistration.partnerId); JSONObject actualInternalrequest = getRequestJson(authInternalRequest); request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPmsClientSecret()); actualInternalrequest.put(GlobalConstants.REQUEST, request); - Response reponse=appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); + Response reponse = appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - + @SuppressWarnings({ "unchecked" }) - public String getAuthForNewPartnerEsignet() { - - JSONObject request=new JSONObject(); + public String getAuthForNewPartnerEsignet() { + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getPmsAppId()); request.put(GlobalConstants.PASSWORD, partner_password); - request.put(GlobalConstants.USER_NAME, AdminTestUtil.genPartnerName); + request.put(GlobalConstants.USER_NAME, AdminTestUtil.genPartnerName); JSONObject actualInternalrequest = getRequestJson(authInternalRequest); request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPmsClientSecret()); actualInternalrequest.put(GlobalConstants.REQUEST, request); - Response reponse=appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); + Response reponse = appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - + @SuppressWarnings({ "unchecked" }) - public String getAuthForPolicytest() { - - JSONObject request=new JSONObject(); + public String getAuthForPolicytest() { + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getPmsAppId()); request.put(GlobalConstants.PASSWORD, props.get("policytest_password")); - request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule +"-"+props.get("policytest_userName")); + request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule + "-" + props.get("policytest_userName")); JSONObject actualInternalrequest = getRequestJson(authInternalRequest); request.put(GlobalConstants.CLIENTID, ConfigManager.getPmsClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getPmsClientSecret()); actualInternalrequest.put(GlobalConstants.REQUEST, request); - Response reponse=appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); + Response reponse = appl.postWithJson(authenticationInternalEndpoint, actualInternalrequest); String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - + @SuppressWarnings("unchecked") public String getAuthForResident() { JSONObject actualrequest = getRequestJson(authRequest); logger.info("actualrequest " + actualrequest); - JSONObject request=new JSONObject(); + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getResidentAppId()); request.put(GlobalConstants.CLIENTID, ConfigManager.getResidentClientId()); request.put(GlobalConstants.SECRETKEY, ConfigManager.getResidentClientSecret()); @@ -330,16 +329,16 @@ public String getAuthForResident() { actualrequest.put(GlobalConstants.REQUEST, request); logger.info(GlobalConstants.ACTU_AUTH_REQUESTFOR_RESIDENT + actualrequest); logger.info(GlobalConstants.ACTU_AUTH_REQUESTFOR_RESIDENT + actualrequest); - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForMobile() { JSONObject actualrequest = getRequestJson(authRequest); logger.info("actualrequest " + actualrequest); - JSONObject request=new JSONObject(); + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getPmsAppId()); request.put(GlobalConstants.CLIENTID, ConfigManager.getMPartnerMobileClientId()); request.put(GlobalConstants.SECRETKEY, ConfigManager.getMPartnerMobileClientSecret()); @@ -348,11 +347,11 @@ public String getAuthForMobile() { actualrequest.put(GlobalConstants.REQUEST, request); logger.info(GlobalConstants.ACTU_AUTH_REQUESTFOR_RESIDENT + actualrequest); logger.info(GlobalConstants.ACTU_AUTH_REQUESTFOR_RESIDENT + actualrequest); - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForNewResidentKc() { @@ -361,7 +360,7 @@ public String getAuthForNewResidentKc() { JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getResidentAppId()); request.put(GlobalConstants.PASSWORD, props.get("new_Resident_Password")); - request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule +"-"+props.get("new_Resident_User")); + request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule + "-" + props.get("new_Resident_User")); request.put(GlobalConstants.CLIENTID, ConfigManager.getResidentClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getResidentClientSecret()); actualrequest.put(GlobalConstants.REQUEST, request); @@ -370,10 +369,10 @@ public String getAuthForNewResidentKc() { String responseBody = reponse.getBody().asString(); return new org.json.JSONObject(responseBody).getJSONObject(dataKey).getString(GlobalConstants.TOKEN); } - + @SuppressWarnings("unchecked") public String getAuthForKeyCloak() { - + Response response = RestAssured.given().with().auth().preemptive() .basic(props.get("keycloak_username"), props.get("keycloak_password")) .header("Content-Type", "application/x-www-form-urlencoded") @@ -383,218 +382,214 @@ public String getAuthForKeyCloak() { .formParam(GlobalConstants.PASSWORD, props.get("keycloak_password")).when() .post(ApplnURIForKeyCloak + props.get("keycloakAuthURL")); logger.info(response.getBody().asString()); - + String responseBody = response.getBody().asString(); String token = new org.json.JSONObject(responseBody).getString(GlobalConstants.ACCESSTOKEN); logger.info(token); return token; } - + @SuppressWarnings("unchecked") public String getAuthForHotlist() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getHotListAppId()); request.put(GlobalConstants.CLIENTID, ConfigManager.getHotListClientId()); request.put(GlobalConstants.SECRETKEY, ConfigManager.getHotListClientSecret()); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") - public String getAuthForIndividual() { - JSONObject actualRequest_generation = getRequestJson("kernel/Authorization/OtpGeneration/request.json"); - ((JSONObject)actualRequest_generation.get(GlobalConstants.REQUEST)).get("userId").toString(); - JSONObject actualRequest_validation = getRequestJson("kernel/Authorization/OtpGeneration/request.json"); - appl.postWithJson(sendOtp, actualRequest_generation); - String otp=null; - if (proxy) - otp = "111111"; - else { - } - ((JSONObject)actualRequest_validation.get(GlobalConstants.REQUEST)).put("otp", otp); - Response otpValidate=appl.postWithJson(useridOTP, actualRequest_validation); - cookie=otpValidate.getCookie(GlobalConstants.AUTHORIZATION); + public String getAuthForIndividual() { + JSONObject actualRequest_generation = getRequestJson("kernel/Authorization/OtpGeneration/request.json"); + ((JSONObject) actualRequest_generation.get(GlobalConstants.REQUEST)).get("userId").toString(); + JSONObject actualRequest_validation = getRequestJson("kernel/Authorization/OtpGeneration/request.json"); + appl.postWithJson(sendOtp, actualRequest_generation); + String otp = null; + if (proxy) + otp = "111111"; + else { + } + ((JSONObject) actualRequest_validation.get(GlobalConstants.REQUEST)).put("otp", otp); + Response otpValidate = appl.postWithJson(useridOTP, actualRequest_validation); + cookie = otpValidate.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") - public String getPreRegToken() { - JSONObject actualRequest_generation = getRequestJson("config/prereg_SendOtp.json"); - actualRequest_generation.put(GlobalConstants.REQUESTTIME, clib.getCurrentUTCTime()); - ((JSONObject)actualRequest_generation.get(GlobalConstants.REQUEST)).put("langCode", BaseTestCase.getLanguageList().get(0)); - ((JSONObject)actualRequest_generation.get(GlobalConstants.REQUEST)).get("userId").toString(); - JSONObject actualRequest_validation = getRequestJson("config/prereg_ValidateOtp.json"); - appl.postWithJson(preregSendOtp, actualRequest_generation); - String otp=null; - if (proxy) - otp = "111111"; - else { - } - ((JSONObject)actualRequest_validation.get(GlobalConstants.REQUEST)).put("otp", otp); - actualRequest_validation.put(GlobalConstants.REQUESTTIME, clib.getCurrentUTCTime()); - Response otpValidate=appl.postWithJson(preregValidateOtp, actualRequest_validation); - cookie=otpValidate.getCookie(GlobalConstants.AUTHORIZATION); + public String getPreRegToken() { + JSONObject actualRequest_generation = getRequestJson("config/prereg_SendOtp.json"); + actualRequest_generation.put(GlobalConstants.REQUESTTIME, clib.getCurrentUTCTime()); + ((JSONObject) actualRequest_generation.get(GlobalConstants.REQUEST)).put("langCode", + BaseTestCase.getLanguageList().get(0)); + ((JSONObject) actualRequest_generation.get(GlobalConstants.REQUEST)).get("userId").toString(); + JSONObject actualRequest_validation = getRequestJson("config/prereg_ValidateOtp.json"); + appl.postWithJson(preregSendOtp, actualRequest_generation); + String otp = null; + if (proxy) + otp = "111111"; + else { + } + ((JSONObject) actualRequest_validation.get(GlobalConstants.REQUEST)).put("otp", otp); + actualRequest_validation.put(GlobalConstants.REQUESTTIME, clib.getCurrentUTCTime()); + Response otpValidate = appl.postWithJson(preregValidateOtp, actualRequest_validation); + cookie = otpValidate.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - @SuppressWarnings("unchecked") public String getAuthForRegistrationProcessor() { - - JSONObject actualrequest = getRequestJson(authRequest); - JSONObject request=new JSONObject(); - request.put(GlobalConstants.APPID, ConfigManager.getRegprocAppId()); - request.put(GlobalConstants.CLIENTID, ConfigManager.getRegprocClientId()); - request.put(GlobalConstants.SECRETKEY, ConfigManager.getRegprocClientSecret()); - actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); - logger.info("Regproc Cookie is:: " + cookie); - return cookie; -} - + + JSONObject actualrequest = getRequestJson(authRequest); + JSONObject request = new JSONObject(); + request.put(GlobalConstants.APPID, ConfigManager.getRegprocAppId()); + request.put(GlobalConstants.CLIENTID, ConfigManager.getRegprocClientId()); + request.put(GlobalConstants.SECRETKEY, ConfigManager.getRegprocClientSecret()); + actualrequest.put(GlobalConstants.REQUEST, request); + + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); + logger.info("Regproc Cookie is:: " + cookie); + return cookie; + } + @SuppressWarnings("unchecked") public String getAuthForRegProc() { - - JSONObject actualrequest = getRequestJson(authRequest); - JSONObject request=new JSONObject(); - request.put(GlobalConstants.APPID, "regproc"); - request.put(GlobalConstants.CLIENTID, "mosip-regproc-client"); - request.put(GlobalConstants.SECRETKEY, "abc123"); - actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); - logger.info("Regproc Cookie is:: " + cookie); - return cookie; -} - - + + JSONObject actualrequest = getRequestJson(authRequest); + JSONObject request = new JSONObject(); + request.put(GlobalConstants.APPID, "regproc"); + request.put(GlobalConstants.CLIENTID, "mosip-regproc-client"); + request.put(GlobalConstants.SECRETKEY, "abc123"); + actualrequest.put(GlobalConstants.REQUEST, request); + + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); + logger.info("Regproc Cookie is:: " + cookie); + return cookie; + } + @SuppressWarnings("unchecked") public String getAuthForIDA() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getResidentAppId()); request.put(GlobalConstants.CLIENTID, ConfigManager.getResidentClientId()); request.put(GlobalConstants.SECRETKEY, ConfigManager.getResidentClientSecret()); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForIDREPO() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getidRepoAppId()); request.put(GlobalConstants.CLIENTID, ConfigManager.getidRepoClientId()); request.put(GlobalConstants.SECRETKEY, ConfigManager.getIdRepoClientSecret()); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(props.get(GlobalConstants.AUTH_CLIENT_IDSECRET_KEYURL), actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForRegistrationAdmin() { JSONObject actualrequest = getRequestJson(authRequest); - JSONObject request=new JSONObject(); + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, registrationAdmin_appid); request.put(GlobalConstants.PASSWORD, registrationAdmin_password); request.put(GlobalConstants.USER_NAME, registrationAdmin_userName); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(authenticationEndpoint, actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(authenticationEndpoint, actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForRegistrationOfficer() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, registrationOfficer_appid); request.put(GlobalConstants.PASSWORD, registrationOfficer_password); request.put(GlobalConstants.USER_NAME, registrationOfficer_userName); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(authenticationEndpoint, actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(authenticationEndpoint, actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForRegistrationSupervisor() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, registrationSupervisor_appid); request.put(GlobalConstants.PASSWORD, registrationSupervisor_password); request.put(GlobalConstants.USER_NAME, registrationSupervisor_userName); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(authenticationEndpoint, actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(authenticationEndpoint, actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForZonalAdmin() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getAdminAppId()); request.put(GlobalConstants.PASSWORD, zonalAdmin_password); request.put(GlobalConstants.USER_NAME, zonalAdmin_userName); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(authenticationEndpoint, actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(authenticationEndpoint, actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForZonalApprover() { JSONObject actualrequest = getRequestJson(authRequest); - - JSONObject request=new JSONObject(); + + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, ConfigManager.getAdminAppId()); request.put(GlobalConstants.PASSWORD, zonalApprover_password); request.put(GlobalConstants.USER_NAME, zonalApprover_userName); actualrequest.put(GlobalConstants.REQUEST, request); - - Response reponse=appl.postWithJson(authenticationEndpoint, actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + + Response reponse = appl.postWithJson(authenticationEndpoint, actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - + @SuppressWarnings("unchecked") public String getAuthForAutoUser() { - JSONObject actualrequest = getRequestJson(authRequest); - JSONObject request=new JSONObject(); + JSONObject actualrequest = getRequestJson(authRequest); + JSONObject request = new JSONObject(); request.put(GlobalConstants.APPID, props.get("autoUsr_appid")); request.put(GlobalConstants.PASSWORD, props.get("autoUsr_password")); request.put(GlobalConstants.USER_NAME, props.get("autoUsr_user")); actualrequest.put(GlobalConstants.REQUEST, request); - Response reponse=appl.postWithJson(authenticationEndpoint, actualrequest); - cookie=reponse.getCookie(GlobalConstants.AUTHORIZATION); + Response reponse = appl.postWithJson(authenticationEndpoint, actualrequest); + cookie = reponse.getCookie(GlobalConstants.AUTHORIZATION); return cookie; } - - - - + } diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 6b3b697b8e5..9948c42092c 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -108,6 +108,7 @@ partner_userName=111997 partner_user_password=mosip123 mosip_pms_client_id=mosip-pms-client mosip_partner_client_id=mosip-partner-client +mosip_partner_client_secret=abc123 mosip_pms_client_secret=abc123 policytest_password=mosip123 policytest_userName=111998 From ac2f4e54b7053dd6ec9c81dfd339c49312ff1ba1 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Mon, 7 Aug 2023 16:50:43 +0530 Subject: [PATCH 017/204] removed mindtree emails --- .../demo/service/controller/JWSSignAndVerifyController.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/JWSSignAndVerifyController.java b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/JWSSignAndVerifyController.java index 113b1558f70..fc1a7d15618 100644 --- a/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/JWSSignAndVerifyController.java +++ b/authentication-demo-service/src/main/java/io/mosip/testrig/authentication/demo/service/controller/JWSSignAndVerifyController.java @@ -246,8 +246,8 @@ public static String getFileContent(FileInputStream fis, String encoding) throws * NoSuchAlgorithmException, CertificateException, InvalidKeyException, * NoSuchProviderException, SignatureException, CertificateParsingException, * CertificateEncodingException, JoseException { String commonName = "sanz"; - * String organizationalUnit = "Mindtree Hi-Tech World"; String organization = - * "Mindtree Limited"; String country = "india"; + * String organizationalUnit = " Hi-Tech World"; String organization = + * "XYZ Limited"; String country = "india"; * * int keySize = 2048; int validDays = 9999; X500Name distinguishedName = new * X500Name(commonName, organizationalUnit, organization, country); KeyPair kp = From 4b144ae0c96e409571e9925a815c2bffeae73155 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Tue, 8 Aug 2023 17:41:07 +0530 Subject: [PATCH 018/204] MOSIP-28598 Handled prereg issue --- .../preReg/createPrereg/createPreregResult.hbs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs b/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs index 89f3dd045fd..416ae065ff4 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs +++ b/automationtests/src/main/resources/preReg/createPrereg/createPreregResult.hbs @@ -5,18 +5,18 @@ "response": { "preRegistrationId": "$IGNORE$", "createdDateTime": "$IGNORE$", - "statusCode": "Application_Incomplete", - "langCode": "{{langCode}}", + "statusCode": "{{statusCode}}", + "langCode": "$IGNORE$", "demographicDetails": { "identity": { - "IDSchemaVersion": $IGNORE$, + "IDSchemaVersion": "$IGNORE$", "fullName": [ { - "language": "$1STLANG$", + "language": "$IGNORE$", "value": "$IGNORE$" }, { - "language": "$2NDLANG$", + "language": "$IGNORE$", "value": "$IGNORE$" } ], From 6f0bd29f61386a1df19d60e4fbc52a3a75d2e110 Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 9 Aug 2023 07:40:28 +0530 Subject: [PATCH 019/204] MOSIP-28844 --- .../resources/preReg/SendNotifications/SendNotifications.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml b/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml index b85dbeab81b..6e067e86270 100644 --- a/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml +++ b/automationtests/src/main/resources/preReg/SendNotifications/SendNotifications.yml @@ -9,7 +9,7 @@ SendNotifications: "id":"mosip.pre-registration.notification.notify", "version":"1.0", "requesttime":"$TIMESTAMP$", - "name":"FR", + "name":"TEST_FULLNAME", "preRegistrationId":"$ID:CreatePrereg_All_Valid_Smoke_BookByPRID_sid_preRegistrationId$", "appointmentDate":"$ID:GetAppointmentDetails_BookByPRID_All_Valid_Smoke_sid_appointment_date$", "appointmentTime":"$ID:GetAppointmentDetails_BookByPRID_All_Valid_Smoke_sid_time_slot_from$", @@ -31,7 +31,7 @@ SendNotifications: "id":"mosip.pre-registration.notification.notify", "version":"1.0", "requesttime":"$TIMESTAMP$", - "name":"FR", + "name":"TEST_FULLNAME", "preRegistrationId":"$ID:CreatePrereg_All_Valid_Smoke_BookByPRID_sid_preRegistrationId$", "appointmentDate":"$ID:GetAppointmentDetails_BookByPRID_All_Valid_Smoke_sid_appointment_date$", "appointmentTime":"$ID:GetAppointmentDetails_BookByPRID_All_Valid_Smoke_sid_time_slot_from$", From 5599701c6f7748d4bcf9d7766639b13a231ec62a Mon Sep 17 00:00:00 2001 From: Anup Nehe Date: Wed, 9 Aug 2023 09:50:37 +0530 Subject: [PATCH 020/204] MOSIP-28847 --- .../io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 416cebf4557..e6871adbc91 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -1376,7 +1376,7 @@ protected Response postWithFormDataAndMultipleFile(String url, String jsonInput, for (File specificFile : listFiles) { if (formParams.get(GlobalConstants.OPERATION).equalsIgnoreCase("insert") && specificFile.getName().equals(formParams.get(GlobalConstants.TABLENAME) + ".csv")) { - specificFile = updateCSV(specificFile.getAbsolutePath(), "OLD", 1, 0); +// specificFile = updateCSV(specificFile.getAbsolutePath(), "OLD", 1, 0); listFiles = new File[1]; listFiles[0] = specificFile; } else { From 692b7352d9de1a87c40281076ab06b80006c2e17 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 9 Aug 2023 11:36:38 +0530 Subject: [PATCH 021/204] MOSIP-28846 --- .../src/main/resources/resident/AuthHistory/AuthHistory.yml | 2 +- .../main/resources/resident/GenerateVID/createGenerateVID.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml index 4a675fe38b3..27b1a14747d 100644 --- a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml +++ b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml @@ -547,7 +547,7 @@ AuthHistory: output: '{ "errors": [ { - "errorCode": "RES-SER-410", + "errorCode": "RES-SER-422", "message": "$IGNORE$" } ], diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index d8bfe54a3ad..e0b4e6dc12a 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -1873,7 +1873,7 @@ GenerateVID: output: '{ "errors": [ { - "errorCode": "RES-SER-410", + "errorCode": "RES-SER-422", "message": "$IGNORE$" } ], From 91005dee06ea2d29ae1cb0bc0772ed3cc3871521 Mon Sep 17 00:00:00 2001 From: neeharikatech <76684248+neeharikatech@users.noreply.github.com> Date: Wed, 9 Aug 2023 15:08:37 +0530 Subject: [PATCH 022/204] MOSIP-28700 --- .../io/mosip/testrig/apirig/global/utils/GlobalMethods.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java index 838f71d3942..ce8f5ece073 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java @@ -8,8 +8,12 @@ public class GlobalMethods { public static void reportRequest(String request) { + if(request!=null) Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + ReportUtil.getTextAreaJsonMsgHtml(request) + GlobalConstants.REPORT_REQUEST_SUFFIX); + else + Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + "Empty Input" + + GlobalConstants.REPORT_REQUEST_SUFFIX); } public static void reportResponse(String url, Response response) { From 06ac640a73e62c486fd5b8b5f2e13659aad53651 Mon Sep 17 00:00:00 2001 From: Pankaj Godiyal Date: Wed, 9 Aug 2023 17:01:21 +0530 Subject: [PATCH 023/204] MOSIP-28604 --- .../testrig/apirig/kernel/util/ConfigManager.java | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index 915e2cf4ad3..c0a868391c3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -63,7 +63,8 @@ public class ConfigManager { private static String ENABLE_DEBUG = "enableDebug"; private static String THREAD_COUNT = "threadCount"; private static String LANG_SELECT = "langselect"; - + private static String ADMIN_USER_NAME = "admin_userName"; + private static String USEPRECONFIGOTP = "usePreConfiguredOtp"; private static String ESIGNET_BASE_URL = "eSignetbaseurl"; @@ -127,6 +128,8 @@ public class ConfigManager { private static String pms_client_id; private static String pms_app_id; private static String partner_client_id; + private static String admin_userName; + private static String resident_client_secret; private static String resident_client_id; @@ -375,6 +378,10 @@ public static void init() { partnerUrlSuffix = System.getenv(PARTNER_URL_SUFFIX) == null ? propsKernel.getProperty(PARTNER_URL_SUFFIX) : System.getenv(PARTNER_URL_SUFFIX); propsKernel.setProperty(PARTNER_URL_SUFFIX, partnerUrlSuffix); + + admin_userName = System.getenv(ADMIN_USER_NAME) == null ? propsKernel.getProperty(ADMIN_USER_NAME) + : System.getenv(ADMIN_USER_NAME); + propsKernel.setProperty(ADMIN_USER_NAME, admin_userName); } @@ -390,6 +397,10 @@ public static boolean isInTobeSkippedList(String stringToFind) { return false; } + public static String getadminUserName() { + return admin_userName; + } + public static String getPartnerUrlSuffix() { return partnerUrlSuffix; } From aea498bb27fb58e554edf658896663b6cebbe297 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 10 Aug 2023 10:56:04 +0530 Subject: [PATCH 024/204] MOSIP-28889 --- .../apirig/admin/fw/util/AdminTestUtil.java | 23 ++- .../apirig/admin/fw/util/TestCaseDTO.java | 1 + .../apirig/admin/fw/util/TestJava.java | 135 ++++++++++++------ .../fw/util/AuditValidation.java | 11 +- .../fw/util/OutputValidationUtil.java | 103 +++++++++---- .../authentication/fw/util/ReportUtil.java | 14 +- .../apirig/global/utils/GlobalMethods.java | 2 +- .../apirig/testscripts/AddIdentity.java | 2 +- .../testrig/apirig/testscripts/BioAuth.java | 2 +- .../apirig/testscripts/BioAuthOld.java | 2 +- .../testscripts/BookAppoinmentByPrid.java | 2 +- .../apirig/testscripts/CreatePreReg.java | 4 +- .../apirig/testscripts/DeleteWithParam.java | 4 +- .../testrig/apirig/testscripts/DemoAuth.java | 2 +- .../DemoAuthSimplePostForAutoGenId.java | 4 +- .../apirig/testscripts/EsignetBioAuth.java | 2 +- .../apirig/testscripts/GetWithParam.java | 4 +- .../testscripts/GetWithParamForAutoGenId.java | 4 +- .../GetWithParamForAutoGenIdForKeyCloak.java | 2 +- .../GetWithParamWithOtpGenerate.java | 6 +- .../apirig/testscripts/GetWithQueryParam.java | 4 +- .../testrig/apirig/testscripts/KycAuth.java | 2 +- .../apirig/testscripts/MassUINGenerator.java | 2 +- .../apirig/testscripts/MultiFactorAuth.java | 4 +- .../testscripts/MultiFactorAuthNew.java | 4 +- .../testrig/apirig/testscripts/OtpAuth.java | 4 +- .../apirig/testscripts/OtpAuthNew.java | 4 +- .../PatchWithBodyWithOtpGenerate.java | 4 +- .../testscripts/PatchWithPathParam.java | 4 +- .../PatchWithPathParamsAndBody.java | 2 +- .../testscripts/PatchWithQueryParam.java | 4 +- .../PostWithAutogenIdWithOtpGenerate.java | 4 +- ...ostWithAutogenIdWithOtpGenerateForWla.java | 4 +- .../PostWithBodyAndPathParams.java | 4 +- ...ostWithBodyAndQueryParamsForAutoGenId.java | 2 +- .../PostWithBodyWithOtpGenerate.java | 4 +- ...WithBodyWithOtpGenerateAndPdfDownload.java | 2 +- .../testscripts/PostWithFormDataAndFile.java | 2 +- ...WithFormDataAndFileForNotificationAPI.java | 2 +- .../PostWithFormDataAndMultipleFile.java | 2 +- .../PostWithFormPathParamAndFile.java | 2 +- .../testscripts/PostWithOnlyPathParam.java | 4 +- .../testscripts/PostWithParamAndFile.java | 2 +- .../PostWithPathParamsAndBody.java | 2 +- .../PostWithPathParamsAndBodyForKeyCloak.java | 2 +- .../apirig/testscripts/PutWithPathParam.java | 4 +- .../testscripts/PutWithPathParamsAndBody.java | 4 +- .../apirig/testscripts/SimpleDelete.java | 4 +- .../apirig/testscripts/SimplePatch.java | 4 +- .../testscripts/SimplePatchForAutoGenId.java | 4 +- .../apirig/testscripts/SimplePost.java | 4 +- .../testscripts/SimplePostForAutoGenId.java | 4 +- .../SimplePostForAutoGenIdForUrlEncoded.java | 4 +- .../SimplePostForDeRegisterDevice.java | 2 +- .../SimplePostForRegisteredDevice.java | 2 +- .../testrig/apirig/testscripts/SimplePut.java | 4 +- .../apirig/testscripts/UpdateDraft.java | 2 +- .../apirig/testscripts/UpdateIdentity.java | 4 +- .../apirig/testscripts/UpdatePrereg.java | 4 +- .../main/resources/config/Kernel.properties | 26 ++-- .../LinkedAuthenticationWla.yml | 50 +++++++ .../UpdateBlockListedWords.yml | 8 +- .../FetchAllDeviceTypes.yml | 1 + .../FetchAllDocumentCategories.yml | 1 + .../FetchAllDocumentTypes.yml | 1 + .../FetchAllMachineType.yml | 1 + .../FetchAllRegCenterType.yml | 1 + .../FetchBlockListedWordByLangcode.yml | 1 + .../masterdata/FetchDevice/FetchDevice.yml | 1 + .../FetchDeviceSpec/FetchDeviceSpec.yml | 3 + .../FetchDocumentCategories.yml | 1 + .../masterdata/FetchMachine/FetchMachine.yml | 4 +- .../FetchMissingRegCenterDetails.yml | 1 + .../masterdata/FetchRegCent/FetchRegCent.yml | 8 ++ .../allTxnDetails.yml | 1 + .../getApplicationConfigs.yml | 6 +- .../HolidaySearch/HolidaySearch.yml | 10 -- .../masterdata/Machine/CreateMachine.yml | 16 +-- .../masterdata/Machine/UpdateMachine.yml | 16 +-- .../MachineTypeSearch/MachineTypeSearch.yml | 1 + .../RegCenterType/UpdateRegCenterType.yml | 2 +- .../SearchDocCategories.yml | 1 + .../SearchDocumentType/SearchDocumentType.yml | 1 + .../SearchMachine/SearchMachine.yml | 32 ----- .../SearchMachineSpec/SearchMachineSpec.yml | 14 +- .../UpdateBlockListedWordDetails.yml | 8 +- .../src/main/resources/masterdata/error.hbs | 2 +- 87 files changed, 413 insertions(+), 260 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 416cebf4557..5015311066a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -286,6 +286,16 @@ private static void settriggerESignetKeyGen7(boolean value) { private static boolean gettriggerESignetKeyGen7() { return triggerESignetKeyGen7; } + + protected static boolean triggerESignetKeyGen8 = true; + + private static void settriggerESignetKeyGen8(boolean value) { + triggerESignetKeyGen8 = value; + } + + private static boolean gettriggerESignetKeyGen8() { + return triggerESignetKeyGen8; + } /** * This method will hit post request and return the response @@ -1376,7 +1386,7 @@ protected Response postWithFormDataAndMultipleFile(String url, String jsonInput, for (File specificFile : listFiles) { if (formParams.get(GlobalConstants.OPERATION).equalsIgnoreCase("insert") && specificFile.getName().equals(formParams.get(GlobalConstants.TABLENAME) + ".csv")) { - specificFile = updateCSV(specificFile.getAbsolutePath(), "OLD", 1, 0); +// specificFile = updateCSV(specificFile.getAbsolutePath(), "OLD", 1, 0); listFiles = new File[1]; listFiles[0] = specificFile; } else { @@ -2946,6 +2956,17 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } jsonString = jsonString.replace("$BINDINGCONSENTSAMECLAIMJWKKEY$", jwkKey); } + + if (jsonString.contains("$BINDINGCONSENTSAMECLAIMVIDJWKKEY$")) { + String jwkKey = ""; + if (gettriggerESignetKeyGen8()) { + jwkKey = generateAndWriteJWKKey(bindingConsentVidSameClaimJWK); + settriggerESignetKeyGen8(false); + } else { + jwkKey = getJWKKey(bindingConsentVidSameClaimJWK); + } + jsonString = jsonString.replace("$BINDINGCONSENTSAMECLAIMVIDJWKKEY$", jwkKey); + } if (jsonString.contains("$OIDCJWKKEY$")) { String jwkKey = ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestCaseDTO.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestCaseDTO.java index a97848bcfc2..a5a53bf6a32 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestCaseDTO.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestCaseDTO.java @@ -16,4 +16,5 @@ public class TestCaseDTO { private boolean regenerateHbs; private boolean validityCheckRequired; private boolean auditLogCheck; + private boolean checkErrorsOnlyInResponse; } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java index 3bf3a3cf876..4315947f147 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java @@ -1,59 +1,112 @@ package io.mosip.testrig.apirig.admin.fw.util; +import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; import java.security.SecureRandom; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.lang.RandomStringUtils; import org.apache.log4j.Logger; +import org.json.JSONArray; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opencsv.CSVWriter; + +import io.mosip.testrig.apirig.testrunner.MosipTestRunner; public class TestJava { private static final Logger lOGGER = Logger.getLogger(TestJava.class); private static final SecureRandom secureRandom = new SecureRandom(); + public static void main(String[] args) { int num = 1011111; - - String transactionID = (num + AdminTestUtil.generateRandomNumberString(8)).substring(0, 10); - lOGGER.info(transactionID); - - Pattern mPattern = Pattern.compile("(|^)\\s\\d{6}\\s"); - - String message = "Dear FR OTP for VID XXXXXXXX65185914 is 333333 and is valid for 3 minutes. (Generated on 21-03-2023 at 16:03:54 Hrs)\r\n" - + "عزيزي $ name OTP لـ $ idvidType $ idvid هو $ otp وهو صالح لـ $ validTime دقيقة. (تم إنشاؤه في $ date في $ time Hrs)\r\n" - + "Cher $name_fra, OTP pour VID XXXXXXXX65185914 est 111111 et est valide pour 3 minutes. (Généré le 21-03-2023 à 16:03:54 Hrs)"; - - message = "Dear TEST_FULLNAMEeng OTP for UIN XXXXXXXX98 is 523478 and is valid for 3 minutes. (Generated on 22-05-2023 at 11:40:11 Hrs) عزيزي $ name OTP لـ $ idvidType $ idvid هو $ otp وهو صالح لـ $ validTime دقيقة. (تم إنشاؤه في $ date في $ time Hrs) UIN XXXXXXXX98 ಗಾಗಿ ಆತ್ಮೀಯ TEST_FULLNAMEkan OTP 523478 ಆಗಿದೆ ಮತ್ತು ಇದು 3 ನಿಮಿಷಗಳವರೆಗೆ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ. (22-05-2023 ದಂದು 11:40:11 ಗಂಟೆಗೆ ರಚಿಸಲಾಗಿದೆ)"; - - if(message!=null) { - Matcher mMatcher = mPattern.matcher(message); - if(mMatcher.find()) { - String otp = mMatcher.group(0); - otp = otp.trim(); - lOGGER.info("Final OTP: "+ otp); - }else { - lOGGER.info("Failed to extract the OTP!! "); - } + + JsonToCsvConverter("E:\\scenarios.json"); + +// String transactionID = (num + AdminTestUtil.generateRandomNumberString(8)).substring(0, 10); +// lOGGER.info(transactionID); +// +// Pattern mPattern = Pattern.compile("(|^)\\s\\d{6}\\s"); +// +// String message = "Dear FR OTP for VID XXXXXXXX65185914 is 333333 and is valid for 3 minutes. (Generated on 21-03-2023 at 16:03:54 Hrs)\r\n" +// + "عزيزي $ name OTP لـ $ idvidType $ idvid هو $ otp وهو صالح لـ $ validTime دقيقة. (تم إنشاؤه في $ date في $ time Hrs)\r\n" +// + "Cher $name_fra, OTP pour VID XXXXXXXX65185914 est 111111 et est valide pour 3 minutes. (Généré le 21-03-2023 à 16:03:54 Hrs)"; +// +// message = "Dear TEST_FULLNAMEeng OTP for UIN XXXXXXXX98 is 523478 and is valid for 3 minutes. (Generated on 22-05-2023 at 11:40:11 Hrs) عزيزي $ name OTP لـ $ idvidType $ idvid هو $ otp وهو صالح لـ $ validTime دقيقة. (تم إنشاؤه في $ date في $ time Hrs) UIN XXXXXXXX98 ಗಾಗಿ ಆತ್ಮೀಯ TEST_FULLNAMEkan OTP 523478 ಆಗಿದೆ ಮತ್ತು ಇದು 3 ನಿಮಿಷಗಳವರೆಗೆ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ. (22-05-2023 ದಂದು 11:40:11 ಗಂಟೆಗೆ ರಚಿಸಲಾಗಿದೆ)"; +// +// if(message!=null) { +// Matcher mMatcher = mPattern.matcher(message); +// if(mMatcher.find()) { +// String otp = mMatcher.group(0); +// otp = otp.trim(); +// lOGGER.info("Final OTP: "+ otp); +// }else { +// lOGGER.info("Failed to extract the OTP!! "); +// } +// } + } + + public static String JsonToCsvConverter(String jsonFilePath) { + String tempCSVPath = "E:\\scenarios.csv"; + try { + ObjectMapper objectMapper = new ObjectMapper(); + JsonNode rootNode = objectMapper.readTree(new File(jsonFilePath)); + + FileWriter fileWriter = new FileWriter(tempCSVPath); + String[] header = { "tc_no", "tags", "persona_class", "persona", "group_name", "description", "step0", + "step1", "step2", "step3", "step4", "step5", "step6", "step7", "step8", "step9", "step10", "step11", + "step12", "step13", "step14", "step15", "step16", "step17", "step18", "step19", "step20", "step21", + "step22", "step23", "step24", "step25", "step26", "step27", "step28", "step29", "step30", "step31", + "step32", "step33", "step34", "step35", "step36", "step37", "step38", "step39", "step40", "step41", + "step42", "step43", "step44", "step45", "step46", "step47", "step48", "step49", "step50" }; + for (String string : header) { + fileWriter.write(string + ","); + } + fileWriter.write("\r\n"); + for (JsonNode jsonNode : rootNode) { + String[] csvLine = { jsonNode.get("tc_no").asText(), jsonNode.get("tags").asText(), + jsonNode.get("persona_class").asText(), jsonNode.get("persona").asText(), + jsonNode.get("group_name").asText(), jsonNode.get("description").asText(), + jsonNode.get("step0") == null ? "" : "\"" + jsonNode.get("step0").asText() + "\"", + jsonNode.get("step1") == null ? "" : "\"" + jsonNode.get("step1").asText() + "\"", + jsonNode.get("step2") == null ? "" : "\"" + jsonNode.get("step2").asText() + "\"", + // ... continue for other fields ... + jsonNode.get("step49") == null ? "" : "\"" + jsonNode.get("step49").asText() + "\"", + jsonNode.get("step50") == null ? "" : "\"" + jsonNode.get("step50").asText() + "\"" }; + for (String string : csvLine) { + fileWriter.write(string + ","); + } + fileWriter.write("\r\n"); + } + fileWriter.close(); + } catch (Exception e) { + } + return tempCSVPath; + } + + public static String generateRandomAlphanumericString(int length) { + byte[] bytes = new byte[length]; + secureRandom.nextBytes(bytes); + String randomString = new String(bytes); + return randomString.replaceAll("[^0-9a-zA-Z]", ""); + } + + public static String generateRandomString(int length) { + byte[] bytes = new byte[length]; + secureRandom.nextBytes(bytes); + String randomString = new String(bytes); + return randomString; + } + + public static String generateRandomNumericString(int length) { + byte[] bytes = new byte[length]; + secureRandom.nextBytes(bytes); + String randomString = new String(bytes); + return randomString.replaceAll("[^0-9]", ""); } - public static String generateRandomAlphanumericString(int length) { - byte[] bytes = new byte[length]; - secureRandom.nextBytes(bytes); - String randomString = new String(bytes); - return randomString.replaceAll("[^0-9a-zA-Z]", ""); - } - - public static String generateRandomString(int length) { - byte[] bytes = new byte[length]; - secureRandom.nextBytes(bytes); - String randomString = new String(bytes); - return randomString; - } - - public static String generateRandomNumericString(int length) { - byte[] bytes = new byte[length]; - secureRandom.nextBytes(bytes); - String randomString = new String(bytes); - return randomString.replaceAll("[^0-9]", ""); - } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java index aedaa16bf32..7196b7074f0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuditValidation.java @@ -10,6 +10,7 @@ import com.fasterxml.jackson.core.JsonParseException; import com.fasterxml.jackson.databind.JsonMappingException; +import io.mosip.testrig.apirig.admin.fw.util.AdminTestException; import io.mosip.testrig.apirig.authentication.fw.dto.OutputValidationDto; import io.mosip.testrig.apirig.global.utils.GlobalConstants; @@ -29,11 +30,12 @@ public class AuditValidation { * @param listOfFiles * @param keywordToFind * @return Map, Output Validation report + * @throws AdminTestException * @throws IOException * @throws JsonMappingException * @throws JsonParseException */ - public static Map> verifyAuditTxn(File[] listOfFiles, String keywordToFind){ + public static Map> verifyAuditTxn(File[] listOfFiles, String keywordToFind) throws AdminTestException{ auth_txn_file = FileUtil.getFileFromList(listOfFiles, keywordToFind); Map exp = AuthTestsUtil.getPropertyAsMap(auth_txn_file.getAbsolutePath()); Map act = DbConnection.getDataForQuery( @@ -41,7 +43,7 @@ public static Map> verifyAuditTxn(File[] listO + exp.get("request_trn_id") + "' order by cr_dtimes desc limit 1", "IDA"); AuthTestsUtil.generateMappingDic(auth_txn_file.getAbsolutePath(), preconAuditKeywords(exp, act)); - return OutputValidationUtil.compareActuExpValue(act, exp, "Audit Transaction Validation"); + return OutputValidationUtil.doJsonOutputValidation(act, exp, false, "Audit Transaction Validation", false); } /** @@ -50,11 +52,12 @@ public static Map> verifyAuditTxn(File[] listO * @param listOfFiles * @param keywordToFind * @return Map, Output Validation report + * @throws AdminTestException * @throws IOException * @throws JsonMappingException * @throws JsonParseException */ - public static Map> verifyAuditLog(File[] listOfFiles, String keywordToFind) { + public static Map> verifyAuditLog(File[] listOfFiles, String keywordToFind) throws AdminTestException { audit_log_file = FileUtil.getFileFromList(listOfFiles, keywordToFind); Map exp = AuthTestsUtil.getPropertyAsMap(audit_log_file.getAbsolutePath()); Map act = null; @@ -74,7 +77,7 @@ public static Map> verifyAuditLog(File[] listO act = DbConnection.getDataForQuery( getAuditLogQuery(exp.get(GlobalConstants.APP_NAME), exp.get(GlobalConstants.MODULE_NAME), exp.get(GlobalConstants.REFID)), GlobalConstants.AUDIT); } - return OutputValidationUtil.compareActuExpValue(act, exp, "Audit Log Validation"); + return OutputValidationUtil.doJsonOutputValidation(act, exp, false, "Audit Log Validation", false); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index 31ea4bbaa39..ee73a5bb4a0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -13,14 +13,17 @@ import java.util.regex.Pattern; import org.apache.log4j.Logger; +import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject; +import org.testng.Assert; import org.testng.Reporter; import org.testng.SkipException; import com.fasterxml.jackson.core.JsonParseException; import com.fasterxml.jackson.databind.JsonMappingException; +import io.mosip.testrig.apirig.admin.fw.util.AdminTestException; import io.mosip.testrig.apirig.authentication.fw.dto.OutputValidationDto; import io.mosip.testrig.apirig.authentication.fw.precon.JsonPrecondtion; import io.mosip.testrig.apirig.authentication.fw.precon.MessagePrecondtion; @@ -43,22 +46,22 @@ public class OutputValidationUtil extends AuthTestsUtil{ * @param expOutputFile * @return map of ouptut validation report */ - public static Map> doOutputValidation(String actualOutputFile, - String expOutputFile) { - try { - Map actual = MessagePrecondtion.getPrecondtionObject(actualOutputFile) - .retrieveMappingAndItsValueToPerformOutputValidation(actualOutputFile); - Map exp = MessagePrecondtion.getPrecondtionObject(expOutputFile) - .retrieveMappingAndItsValueToPerformOutputValidation(expOutputFile); - actualOutputFile = actualOutputFile.substring(actualOutputFile.lastIndexOf("/") + 1, - actualOutputFile.length()); - expOutputFile = expOutputFile.substring(expOutputFile.lastIndexOf("/") + 1, expOutputFile.length()); - return compareActuExpValue(actual, exp, actualOutputFile + " vs " + expOutputFile); - } catch (Exception e) { - OUTPUTVALIDATION_LOGGER.error("Exceptione occured " + e.getMessage()); - return Collections.emptyMap(); - } - } +// public static Map> doOutputValidation(String actualOutputFile, +// String expOutputFile) { +// try { +// Map actual = MessagePrecondtion.getPrecondtionObject(actualOutputFile) +// .retrieveMappingAndItsValueToPerformOutputValidation(actualOutputFile); +// Map exp = MessagePrecondtion.getPrecondtionObject(expOutputFile) +// .retrieveMappingAndItsValueToPerformOutputValidation(expOutputFile); +// actualOutputFile = actualOutputFile.substring(actualOutputFile.lastIndexOf("/") + 1, +// actualOutputFile.length()); +// expOutputFile = expOutputFile.substring(expOutputFile.lastIndexOf("/") + 1, expOutputFile.length()); +// return compareActuExpValue(actual, exp, actualOutputFile + " vs " + expOutputFile); +// } catch (Exception e) { +// OUTPUTVALIDATION_LOGGER.error("Exceptione occured " + e.getMessage()); +// return Collections.emptyMap(); +// } +// } /** * The method will compare expected and actual value @@ -74,6 +77,7 @@ public static Map> compareActuExpValue(Map exp, String actVsExp) { Map> objMap = new HashMap<>(); List objList = new ArrayList(); + boolean comparisonDone = false; try { for (Entry actualEntry : actual.entrySet()) { OutputValidationDto objOpDto = new OutputValidationDto(); @@ -96,6 +100,7 @@ public static Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> compareActuExpValue(Map> doJsonOutputValidation(String actualOutputJson, - String expOutputJson) { + String expOutputJson, boolean checkErrorsOnlyInResponse) throws AdminTestException { + return doJsonOutputValidation(actualOutputJson, + expOutputJson, checkErrorsOnlyInResponse, "expected vs actual", doesResponseHasErrors(actualOutputJson)); + } + + public static Map> doJsonOutputValidation(String actualOutputJson, + String expOutputJson, boolean checkErrorsOnlyInResponse, String context, boolean responseHasErrors) throws AdminTestException { + JsonPrecondtion jsonPrecondtion = new JsonPrecondtion(); + Map actual = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(actualOutputJson); + Map exp = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(expOutputJson); + + return doJsonOutputValidation(actual, exp, checkErrorsOnlyInResponse, context, responseHasErrors); + } + + public static Map> doJsonOutputValidation(Map actualOutput, + Map expOutput, boolean checkErrorsOnlyInResponse, String context, boolean responseHasErrors) throws AdminTestException { + try { - JsonPrecondtion jsonPrecondtion = new JsonPrecondtion(); - Map actual = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(actualOutputJson); - Map exp = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(expOutputJson); - return compareActuExpValue(actual, exp, "expected vs actual"); - } catch (Exception e) { - OUTPUTVALIDATION_LOGGER.error("Exceptione occured " + e.getMessage()); - return Collections.emptyMap(); + return compareActuExpValue(actualOutput, expOutput, context); + }catch (SkipException e) { + if (responseHasErrors) + throw new AdminTestException("Response has errors"); + else if(!checkErrorsOnlyInResponse) + throw new SkipException(e.getMessage()); + else + return Collections.emptyMap(); // No output validation required. Hence marking the test case as passed + } + } + + public static boolean doesResponseHasErrors(String responseString) { + JSONObject responseJson = new JSONObject(responseString); + boolean breturn = false; + JSONArray errors = null; + if (responseJson.has("errors")) { + errors = responseJson.optJSONArray("errors"); } + + if (errors != null) + breturn = (errors.length() > 0); + + return breturn; } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java index b4ff03b752f..ce4f81055a9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java @@ -28,18 +28,22 @@ public static String getOutputValidationReport(Map\r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n"; + boolean outputValidationDone = false; + String temp = ""; for (Entry> entry : outputresult.entrySet()) { - Reporter.log(" Output validation for: " + entry.getKey()); + temp = " Output validation for: " + entry.getKey()+ "\r\n"; for (OutputValidationDto dto : entry.getValue()) { if (dto.getStatus().equals("PASS")) { htmlforReport = htmlforReport + " \r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n"; + outputValidationDone = true; } else if (dto.getStatus().equals(GlobalConstants.FAIL_STRING)) { htmlforReport = htmlforReport + " \r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n"; + outputValidationDone = true; } // If it is warning basically we haven't compared or ignored the comparison. // so no point in printing that content in the report. @@ -52,13 +56,17 @@ public static String getOutputValidationReport(Map"; + if (!outputValidationDone) { + return " Marking test case as passed. As Output validation not performed and no errors in the response "; + } + + htmlforReport = temp + htmlforReport + "
Test# Passed# Skipped# FailedTime (ms)Included GroupsExcluded Groups
"); writer.print(Utils.escapeHtml(suiteResult.getSuiteName() + "-" + getCommitId())); writer.print(GlobalConstants.TRTR); @@ -227,6 +219,16 @@ protected void writeSuiteSummary() { writer.print(""); writer.print(GlobalConstants.TRTR); + writer.print("
Test# Passed# Skipped# FailedTime (ms)Included GroupsExcluded Groups
FieldNameExpected ValueActual ValueStatus
" + dto.getFieldName() + "" + dto.getExpValue() + "" + dto.getActualValue() + "" + dto.getStatus() + "
" + dto.getFieldName() + "" + dto.getExpValue() + "" + dto.getActualValue() + "" + dto.getStatus() + "
"; return htmlforReport; } /** - * Publish the request and response message in textarea + * Publish the request and response message in text area * * @param content * @return test area html diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java index 838f71d3942..03d917026f3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java @@ -8,7 +8,7 @@ public class GlobalMethods { public static void reportRequest(String request) { - Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + ReportUtil.getTextAreaJsonMsgHtml(request) + Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + ReportUtil.getTextAreaJsonMsgHtml(request == null ? "No request body" : request) + GlobalConstants.REPORT_REQUEST_SUFFIX); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java index d696a7826d9..ca0c6f7e747 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java @@ -127,7 +127,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java index e4f6524c071..8a35e6ec506 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java @@ -146,7 +146,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), ActualOPJson); + .doJsonOutputValidation(response.asString(), ActualOPJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java index df9282c1484..693525a6f10 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java @@ -133,7 +133,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java index 8ad743a3569..5c995fd3e1d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java @@ -98,7 +98,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response = postWithBodyAndCookie(ApplnURI + testCaseDTO.getEndPoint(), inputJosn, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java index 1c30de13ddb..b9ef3257d6e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java @@ -97,7 +97,7 @@ public void test(TestCaseDTO testCaseDTO) Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); if (testCaseDTO.getTestCaseName().toLowerCase().contains("dynamic")) { JSONObject json = new JSONObject(response.asString()); idField = json.getJSONObject("response").get("id").toString(); @@ -111,7 +111,7 @@ public void test(TestCaseDTO testCaseDTO) response = postWithBodyAndCookieForAutoGeneratedId(ApplnURI + testCaseDTO.getEndPoint(), inputJson, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), idKeyName); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), outputJson); + .doJsonOutputValidation(response.asString(), outputJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java index 58e42d8b96d..daaae224cf5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java @@ -86,7 +86,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -99,7 +99,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad getJsonFromTemplate(testCaseDTO.getInput(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), sendEsignetToken); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java index 827c708bd06..d97cb32fcc9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java @@ -156,7 +156,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), ActualOPJson); + .doJsonOutputValidation(response.asString(), ActualOPJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java index feab4e31438..425051e8110 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java @@ -134,7 +134,7 @@ public void test(TestCaseDTO testCaseDTO) Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); if (testCaseDTO.getTestCaseName().toLowerCase().contains("dynamic")) { JSONObject json = new JSONObject(response.asString()); idField = json.getJSONObject("response").get("id").toString(); @@ -179,7 +179,7 @@ public void test(TestCaseDTO testCaseDTO) } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), ActualOPJson); + .doJsonOutputValidation(response.asString(), ActualOPJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java index 317f30b6aab..9e8e5d2cc03 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java @@ -177,7 +177,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), ActualOPJson); + .doJsonOutputValidation(response.asString(), ActualOPJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java index 371aa5ecfb2..390cd4c68ef 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java @@ -101,7 +101,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -130,7 +130,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java index 63e4c307aa0..3fd3d0ecee0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java @@ -90,7 +90,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -110,7 +110,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java index 3e5028981d1..581f1558a13 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java @@ -79,7 +79,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { getJsonFromTemplate(testCaseDTO.getInput(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), idKeyName); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java index e12815875eb..df06e12d9f0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java @@ -103,7 +103,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil - .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { @@ -161,7 +161,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -174,7 +174,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad getJsonFromTemplate(testCaseDTO.getInput(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java index 8c8ba83cf10..7e3d3909953 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java @@ -87,7 +87,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -116,7 +116,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java index 70308cd36b5..bd4540595cd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java @@ -126,7 +126,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad COOKIENAME, token, headers, testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java index f8746f23a51..fdbbc0394c6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java @@ -100,7 +100,7 @@ public void createUins(TestCaseDTO testCaseDTO, int count) throws Authentication Response response = postWithBodyAndCookie(ApplnURI + testCaseDTO.getEndPoint(), inputJson, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); boolean publishResult = OutputValidationUtil.publishOutputResult(ouputValid); if (!publishResult) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java index b25f65bcd2e..b8d7322f67a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java @@ -118,7 +118,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( - otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); OutputValidationUtil.publishOutputResult(ouputValidOtp); @@ -177,7 +177,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java index d053f64b222..6dcacbf7be7 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java @@ -147,7 +147,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( - otpRespon.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + otpRespon.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) @@ -192,7 +192,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), ActualOPJson); + .doJsonOutputValidation(response.asString(), ActualOPJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java index 82571f07824..579053016a9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java @@ -127,7 +127,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil - .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) @@ -153,7 +153,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { response = postRequestWithCookieAuthHeaderAndSignature(ApplnURI + testCaseDTO.getEndPoint(), authRequest, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java index 36a76d73a5c..fc82c0904fd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java @@ -149,7 +149,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( - otpRespon.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + otpRespon.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) @@ -210,7 +210,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad } } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), ActualOPJson); + .doJsonOutputValidation(response.asString(), ActualOPJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java index fdee42a572b..db8a92f3f58 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java @@ -91,7 +91,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil - .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { @@ -104,7 +104,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Response response = patchRequestWithCookieAndHeader(ApplnURI + testCaseDTO.getEndPoint(), getJsonFromTemplate(req.toString(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java index 0f124b726e3..d0cd97c1ada 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java @@ -78,7 +78,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -90,7 +90,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response = patchWithPathParamAndCookie(ApplnURI + testCaseDTO.getEndPoint(), getJsonFromTemplate(testCaseDTO.getInput(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java index d3ad96d576d..5785fee9f2c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java @@ -78,7 +78,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { response = patchWithPathParamsBodyAndCookie(ApplnURI + testCaseDTO.getEndPoint(), inputJson, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), pathParams); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java index 63c5673e19f..82ed1a05c92 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java @@ -83,7 +83,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -97,7 +97,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java index 1c6500a5f18..d4fd6c1bd5a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java @@ -143,7 +143,7 @@ public void test(TestCaseDTO testCaseDTO) sendOtpRespJson.remove("sendOtpResTemplate"); if (otpResponse != null) { Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( - otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { @@ -177,7 +177,7 @@ public void test(TestCaseDTO testCaseDTO) Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java index d52e22f067e..8ce0328ddcd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java @@ -108,7 +108,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil - .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) @@ -144,7 +144,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java index aa97b80454b..92724e3c7f9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java @@ -89,7 +89,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -105,7 +105,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response = postWithPathParamsBodyAndCookie(ApplnURI + testCaseDTO.getEndPoint(), inputJson, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), pathParams); } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), outputJson); + .doJsonOutputValidation(response.asString(), outputJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java index d40d6c011ba..5aebe655d09 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java @@ -73,7 +73,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java index ce9e07a8dd8..e66ccfd396b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java @@ -112,7 +112,7 @@ else if(testCaseName.contains("ESignet_WalletBinding")) { sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil - .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) { @@ -139,7 +139,7 @@ else if(testCaseName.contains("ESignet_WalletBinding")) { response = postRequestWithCookieAndHeader(ApplnURI + testCaseDTO.getEndPoint(), getJsonFromTemplate(req.toString(), testCaseDTO.getInputTemplate()), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), sendEsignetToken); } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(res.toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java index 24fbc0be1b0..fc7eb23a0d1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java @@ -104,7 +104,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil - .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + .doJsonOutputValidation(otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java index 16e3da53c61..8996c197b0c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java @@ -71,7 +71,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response = postWithFormDataAndMultipleFile(ApplnURI + testCaseDTO.getEndPoint(), getJsonFromTemplate(testCaseDTO.getInput(), testCaseDTO.getInputTemplate()), testCaseDTO.getRole(), testCaseDTO.getTestCaseName(),idKeyName); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java index eee897929bf..8dd149e4063 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java @@ -76,7 +76,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { response = postWithMultipartFormDataAndFile(ApplnURI + testCaseDTO.getEndPoint(), inputJson, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(),idKeyName); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java index c8c88c058ac..b9c96b941fd 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java @@ -71,7 +71,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response = postWithFormDataAndMultipleFile(ApplnURI + testCaseDTO.getEndPoint(), getJsonFromTemplate(testCaseDTO.getInput(), testCaseDTO.getInputTemplate()), testCaseDTO.getRole(), testCaseDTO.getTestCaseName(),idKeyName); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java index 6da1d24471d..63715a2dbe2 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java @@ -84,7 +84,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java index 2ebd7ac5f85..c743eccba02 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java @@ -81,7 +81,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -101,7 +101,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java index 4b821cb365f..3350ba4c615 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java @@ -88,7 +88,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java index 3b11dbd9c72..76991ab1673 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java @@ -112,7 +112,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Response response = postWithPathParamsBodyAndCookie(ApplnURI + testCaseDTO.getEndPoint(), inputJosn, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), pathParams); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java index 3b1894dc6dc..37e3f5deaa5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java @@ -71,7 +71,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Response response = postWithPathParamsBodyAndCookie(ApplnURIForKeyCloak + testCaseDTO.getEndPoint(), testCaseDTO.getInput(), COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), pathParams); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java index 669b60fdeda..29e83c97974 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java @@ -80,7 +80,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -94,7 +94,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java index 319cb969044..40527a954a9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java @@ -86,7 +86,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -111,7 +111,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java index a8eb913785e..2eccd10a586 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java @@ -75,7 +75,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -109,7 +109,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java index 0d74e6b3f48..665e5d05915 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java @@ -84,7 +84,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -106,7 +106,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java index 6ac445a01cc..1b8f53a57a3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java @@ -82,7 +82,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -96,7 +96,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.getRole(), testCaseDTO.getTestCaseName(),idKeyName); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java index c0503074672..9c7a8958d39 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java @@ -96,7 +96,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -130,7 +130,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java index 0a21e9f16ad..d0ff6f9128b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java @@ -108,7 +108,7 @@ public void test(TestCaseDTO testCaseDTO) Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); if (testCaseDTO.getTestCaseName().toLowerCase().contains("dynamic")) { JSONObject json = new JSONObject(response.asString()); idField = json.getJSONObject("response").get("id").toString(); @@ -147,7 +147,7 @@ public void test(TestCaseDTO testCaseDTO) ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java index 72f173b30fd..b45269ab97f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java @@ -96,7 +96,7 @@ public void test(TestCaseDTO testCaseDTO) Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); if (testCaseDTO.getTestCaseName().toLowerCase().contains("dynamic")) { JSONObject json = new JSONObject(response.asString()); idField = json.getJSONObject("response").get("id").toString(); @@ -119,7 +119,7 @@ public void test(TestCaseDTO testCaseDTO) } Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), outputJson); + .doJsonOutputValidation(response.asString(), outputJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java index 7851da2cb07..28886910586 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java @@ -79,7 +79,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java index adae736bd69..2478f20c15e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java @@ -87,7 +87,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad regDeviceResponse = (String) ctx.read("$.response"); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + .doJsonOutputValidation(response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java index f32cbe9edbc..da81c5fc5e8 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java @@ -89,7 +89,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -110,7 +110,7 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { ouputValid.put("expected vs actual", List.of(customResponse)); }else { ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } logger.info(ouputValid); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java index ae15a726516..2f10cc5a74e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java @@ -114,7 +114,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), pathParams); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java index 0013fe20473..32b5e93c01e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java @@ -140,7 +140,7 @@ public void updateIdentity(TestCaseDTO testCaseDTO) throws AuthenticationTestExc testCaseDTO.getRole(), testCaseDTO.getTestCaseName()); Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( - response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate())); + response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); Assert.assertEquals(OutputValidationUtil.publishOutputResult(ouputValid), true); @@ -153,7 +153,7 @@ public void updateIdentity(TestCaseDTO testCaseDTO) throws AuthenticationTestExc sendOtpResTemplate = sendOtpRespJson.getString("sendOtpResTemplate"); sendOtpRespJson.remove("sendOtpResTemplate"); Map> ouputValidOtp = OutputValidationUtil.doJsonOutputValidation( - otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate)); + otpResponse.asString(), getJsonFromTemplate(sendOtpRespJson.toString(), sendOtpResTemplate), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValidOtp)); if (!OutputValidationUtil.publishOutputResult(ouputValidOtp)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java index c5d32c7fa8a..4b55b6c2651 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java @@ -122,7 +122,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad Map> ouputValid = OutputValidationUtil.doJsonOutputValidation( response.asString(), - getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate())); + getJsonFromTemplate(outputtestcase.get(i).toString(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) @@ -134,7 +134,7 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response = putWithPathParamsBodyAndCookie(ApplnURI + testCaseDTO.getEndPoint(), inputJson, COOKIENAME, testCaseDTO.getRole(), testCaseDTO.getTestCaseName(), pathParams); Map> ouputValid = OutputValidationUtil - .doJsonOutputValidation(response.asString(), outputJson); + .doJsonOutputValidation(response.asString(), outputJson, testCaseDTO.isCheckErrorsOnlyInResponse()); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 9948c42092c..36cd118cbce 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -109,43 +109,43 @@ partner_user_password=mosip123 mosip_pms_client_id=mosip-pms-client mosip_partner_client_id=mosip-partner-client mosip_partner_client_secret=abc123 -mosip_pms_client_secret=abc123 +mosip_pms_client_secret=Tkx3jw9INusggEDW policytest_password=mosip123 policytest_userName=111998 #RESIDENT & IDA mosip_resident_app_id=resident mosip_resident_client_id=mosip-resident-client -mosip_resident_client_secret=abc123 +mosip_resident_client_secret=UGq78khkAst6fjbn #IDREPO mosip_idrepo_app_id=idrepo mosip_idrepo_client_id=mosip-idrepo-client -mosip_idrepo_client_secret=abc123 +mosip_idrepo_client_secret=wJ21F8gXzdy2RM9q #admin mosip_admin_app_id=admin admin_password=mosip123 admin_userName=220005 mosip_admin_client_id=mosip-admin-client -mosip_admin_client_secret=xyz123 +mosip_admin_client_secret=7Vvj405Z5a35eAod #admin admin_zone_password=mosip123 admin_zone_userName=globaladmin mosip_regclient_app_id=registrationclient mosip_reg_client_id=mosip-reg-client -mosip_reg_client_secret=abc123 +mosip_reg_client_secret=SGqovDBMh7McnAxw #admin mosip_regprocclient_app_id=regproc mosip_regproc_client_id=mosip-regproc-client -mosip_regproc_client_secret=abc123 +mosip_regproc_client_secret=lntJVPztZAOYpmTR #mparter_mobile mpartner_default_mobile_client_id=mpartner-default-mobile -mpartner_default_mobile_secret=3adc8ff6-29a1-4149-9193-21752eb2f07a +mpartner_default_mobile_secret=Gif10hl5sFH6WCUi #This credentials are used to execute auth demo service AuthClientID=mosip-resident-client -AuthClientSecret=abc123 +AuthClientSecret=UGq78khkAst6fjbn AuthAppID=resident mosip_hotlist_app_id=hotlist mosip_hotlist_client_id=mosip-hotlist-client @@ -160,11 +160,11 @@ roles.111995=PARTNER_ADMIN,default-roles-mosip keycloak_UserName = admin -keycloak_Password = admin +keycloak_Password = oY6ijJuIL8 -keycloak-external-url=https://qa-115.mosip.net/keycloak +keycloak-external-url=https://iam.dev3.mosip.net mosip_testrig_client_id=mosip-testrig-client -mosip_testrig_client_secret=abc123 +mosip_testrig_client_secret=aOCfcQC2dYm2Iotg keycloak-realm-id=mosip iam-users-to-create=111997,111998,220005,111992,globaladmin @@ -182,14 +182,14 @@ dialect=org.hibernate.dialect.PostgreSQLDialect show_sql=true current_session_context_class=thread #audit details -audit_url=jdbc:postgresql://qa-115.mosip.net:5432/mosip_audit +audit_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_audit audit_username=postgres audit_password=rLqRHeY4C5 audit_default_schema=audit #ida-partner details DB_PORT= installation-domain= -partner_url=jdbc:postgresql://qa-115.mosip.net:5432/mosip_ida +partner_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_ida partner_username=postgres partner_password=rLqRHeY4C5 partner_default_schema=partner diff --git a/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml b/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml index bd3e913b02a..bd39f91655c 100644 --- a/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml +++ b/automationtests/src/main/resources/esignet/LinkedAuthenticationWla/LinkedAuthenticationWla.yml @@ -49,6 +49,56 @@ LinkedAuthenticationWla: } }' + ESignet_LinkedAuthenticationWla_Consent_SameClaim_Vid_SCert_all_Valid_Smoke_sid: + endPoint: /v1/esignet/linked-authorization/v2/authenticate + role: resident + restMethod: post + validityCheckRequired: true + inputTemplate: esignet/LinkedAuthenticationWla/LinkedAuthenticationWla + outputTemplate: esignet/LinkedConsent/LinkedAuthenticationConsentWla/LinkedAuthenticationConsentWlaResult + input: '{ + "requestTime": "$TIMESTAMP$", + "linkTransactionId": "$ID:LinkTransaction_Consent_Vid_SameClaim_all_Valid_Smoke_sid_linkTransactionId$", + "individualId": "$ID:Generate_Perpetual_VID_Linked_Consent_Valid_Smoke_sid_vid$", + "authFactorType": "WLA", + "challenge": "$WLATOKENCONSENTVIDSAMECLAIM$", + "format": "jwt", + "sendOtp":{ + "apiKey": "$ID:GenerateApiKey_Valid_Smoke_sid_apiKey$", + "partnerId": "$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Linked_Consent_Valid_Smoke_sid_vid$", + "otpChannels": [{channel: "email"},{channel: "phone"}], + "sendOtpReqTemplate": "esignet/SendBindingOtp/SendBindingOtp", + "sendOtpEndPoint": "/v1/esignet/binding/binding-otp", + }, + "validateOtp":{ + "apiKey": "$ID:GenerateApiKey_Valid_Smoke_sid_apiKey$", + "partnerId": "$ID:PartnerSelfRegistration_All_Valid_Smoke_sid_partnerId$", + "requestTime": "$TIMESTAMP$", + "individualId": "$ID:Generate_Perpetual_VID_Linked_Consent_Valid_Smoke_sid_vid$", + "authFactorType1": "WLA", + "format1": "jwt", + "authFactorType": "OTP", + "challenge": "$ID:AddIdentity_Linked_Consent_Vid_smoke_Pos_EMAIL$", + "format": "alpha-numeric", + "publicKey": "$BINDINGCONSENTSAMECLAIMVIDJWKKEY$", + "validateOtpReqTemplate": "esignet/WalletBinding/WalletBinding", + "validateOtpEndPoint": "/v1/esignet/binding/wallet-binding" + } +}' + output: '{ + "consentAction": "NOCAPTURE", + "sendOtpResp":{ + "maskedMobile": "$IGNORE$", + "sendOtpResTemplate":"esignet/SendBindingOtp/SendBindingOtpResult", + "maskedEmail": "$IGNORE$" + }, + "validateOtpResp":{ + "sendOtpResTemplate":"esignet/WalletBinding/WalletBindingResult" + } +}' + ESignet_LinkedAuthenticationWla_uin_SCert_all_Valid_Smoke_sid: endPoint: /v1/esignet/linked-authorization/authenticate role: resident diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml b/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml index c9752e66f63..dc8d9f3df90 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/UpdateBlockListedWords.yml @@ -103,8 +103,12 @@ UpdateBlockListedWords: "requesttime": "$TIMESTAMP$" }' output: '{ - "word": "bullwordupd", - "langCode": "eng" + "errors": [ + { + "errorCode": "KER-MSD-008", + "message": "$IGNORE$" + } + ] }' Masterdata_UpdateBlockListedWords_Invalid_DescriptionLength257: endPoint: /v1/masterdata/blocklistedwords diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml index 8d80bcc0567..1bad4dc3846 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml @@ -2,6 +2,7 @@ FetchAllDeviceType: MasterData_FetchAllDeviceTypes_valid_smoke: endPoint: /v1/masterdata/devicetypes/all role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchAllDeviceType/fetchAllDeviceTypes diff --git a/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/FetchAllDocumentCategories.yml b/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/FetchAllDocumentCategories.yml index 0e218949ec3..0397c3b7ef8 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/FetchAllDocumentCategories.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllDocumentCategories/FetchAllDocumentCategories.yml @@ -2,6 +2,7 @@ FetchAllDocumentCategories: MasterData_FetchAllDocumentCategories_valid_smoke_langcodeandCode: endPoint: /v1/masterdata/documentcategories/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllDocumentCategories/fetchAllDocumentCategories outputTemplate: masterdata/FetchAllDocumentCategories/fetchAllDocumentCategoriesResult diff --git a/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/FetchAllDocumentTypes.yml b/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/FetchAllDocumentTypes.yml index fa141f874d1..64353435d01 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/FetchAllDocumentTypes.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllDocumentTypes/FetchAllDocumentTypes.yml @@ -2,6 +2,7 @@ FetchAllDocumentTypes: MasterData_FetchAllDocumentTypes_valid_smoke_langcodeandCode: endPoint: /v1/masterdata/documentcategories/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllDocumentTypes/fetchAllDocumentTypes outputTemplate: masterdata/FetchAllDocumentTypes/fetchAllDocumentTypesResult diff --git a/automationtests/src/main/resources/masterdata/FetchAllMachineType/FetchAllMachineType.yml b/automationtests/src/main/resources/masterdata/FetchAllMachineType/FetchAllMachineType.yml index 494cbdad704..ff89bc1069e 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllMachineType/FetchAllMachineType.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllMachineType/FetchAllMachineType.yml @@ -2,6 +2,7 @@ FetchAllMachineType: MasterData_FetchAllMachineType_valid_smoke_langcodeandCode: endPoint: /v1/masterdata/machinetypes/all role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchAllMachineType/fetchAllMachineType diff --git a/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml b/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml index 5571db7aa86..1f0dc88b58f 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllRegCenterType/FetchAllRegCenterType.yml @@ -2,6 +2,7 @@ FetchAllRegCenterType: MasterData_FetchAllRegCenterType_valid_smoke: endPoint: /v1/masterdata/registrationcentertypes/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllRegCenterType/fetchAllRegCenterType outputTemplate: masterdata/FetchAllRegCenterType/fetchAllRegCenterTypeResult diff --git a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml index fa8bbebdc99..d0988fa1167 100644 --- a/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml +++ b/automationtests/src/main/resources/masterdata/FetchBlockListedWordByLangcode/FetchBlockListedWordByLangcode.yml @@ -2,6 +2,7 @@ FetchBlockListedWordByLangcode: Masterdata_FetchBlockListedWordByLangcode_valid_eng_smoke: endPoint: /v1/masterdata/blocklistedwords/{langCode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langCode"] restMethod: get inputTemplate: masterdata/FetchBlockListedWordByLangcode/fetchBlockListedWordByLangcode diff --git a/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml b/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml index d755791f3c9..fafcab83d84 100644 --- a/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml +++ b/automationtests/src/main/resources/masterdata/FetchDevice/FetchDevice.yml @@ -52,6 +52,7 @@ FetchDevice: MasterData_FetchDevice_allValid_smoke_with_regCentre: endPoint: /v1/masterdata/devices/mappeddevices/{regCenterId} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchDevice/fetchDevice outputTemplate: masterdata/FetchDevice/fetchDeviceByCenterResult diff --git a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml index 370c1301f2a..aba0961abe0 100644 --- a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/FetchDeviceSpec.yml @@ -2,6 +2,7 @@ FetchDeviceSpec: MasterData_FetchDeviceSpec_allValid_smoke_with_lang: endPoint: /v1/masterdata/devicespecifications/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchDeviceSpec/fetchDeviceSpec @@ -19,6 +20,7 @@ FetchDeviceSpec: MasterData_FetchDeviceSpec_allValid_byDeviceTypeCode_smoke: endPoint: /v1/masterdata/devicespecifications/devicetypecode/{devicetypecode} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchDeviceSpec/fetchDeviceSpec @@ -36,6 +38,7 @@ FetchDeviceSpec: MasterData_FetchDeviceSpec_allValid_smoke_with_lang_and_deviceType: endPoint: /v1/masterdata/devicespecifications/{langcode}/{devicetypecode} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchDeviceSpec/fetchDeviceSpec diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml index 252159ed8ed..c3caa3c3366 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml +++ b/automationtests/src/main/resources/masterdata/FetchDocumentCategories/FetchDocumentCategories.yml @@ -40,6 +40,7 @@ FetchDocumentCategories: MasterData_FetchDocumentCategories_valid_smoke_langcode: endPoint: /v1/masterdata/documentcategories/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchDocumentCategories/fetchDocumentCategories diff --git a/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml b/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml index b905e9dad73..bbde44ad32b 100644 --- a/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml +++ b/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml @@ -43,9 +43,7 @@ FetchMachine: "regCenterId": "10011" }' output: '{ -"machines": [{ - "isActive": true - }] + "isActive": true }' Masterdata_FetchMachine_inValid_regCenterId: endPoint: /v1/masterdata/machines/mappedmachines/{regCenterId} diff --git a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml index a6112846e96..2ca75329f00 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterDetails/FetchMissingRegCenterDetails.yml @@ -2,6 +2,7 @@ FetchMissingRegCenterDetails: MasterData_FetchMissingRegCenterDetails_valid_smoke: endPoint: /v1/masterdata/registrationcenters/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchMissingRegCenterDetails/fetchMissingRegCenterDetails outputTemplate: masterdata/FetchMissingRegCenterDetails/fetchMissingRegCenterDetailsResult diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml index b451b8db99f..8b72400c8f0 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml @@ -2,6 +2,7 @@ FetchRegCent: MasterData_FetchRegCent_allValid_smoke: endPoint: /v1/masterdata/registrationcenters role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -28,6 +29,7 @@ FetchRegCent: MasterData_FetchRegCent_coordinate_specific_allValid_smoke: endPoint: /v1/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -111,6 +113,7 @@ FetchRegCent: MasterData_FetchRegCent_By_LocationCode_allValid_smoke: endPoint: /v1/masterdata/getlocspecificregistrationcenters/{langcode}/{locationcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -219,6 +222,7 @@ FetchRegCent: MasterData_FetchRegCent_By_id_allValid_smoke: endPoint: /v1/masterdata/registrationcenters/{id}/{langcode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -331,6 +335,7 @@ FetchRegCent: MasterData_FetchRegCent_By_HierarchyLevel__ListText_langCode_allValid_smoke: endPoint: /v1/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name=Rabat Sale Kenitra role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -438,6 +443,7 @@ FetchRegCent: MasterData_FetchRegCent_by_langCode_zoneCode_allValid_smoke: endPoint: /v1/masterdata/getzonespecificregistrationcenters/{langcode}/{zonecode} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -494,6 +500,7 @@ FetchRegCent: endPoint: /v1/masterdata/registrationcenters/{langcode}/{hierarchylevel}/{name} role: admin templateFields: ["name"] + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent outputTemplate: masterdata/FetchRegCent/fetchAllRegCentWithPaginationResult @@ -579,6 +586,7 @@ FetchRegCent: MasterData_FetchRegCent_By_zoneCode: endPoint: /v1/masterdata/getzonespecificregistrationcenters/{langcode}/{zonecode} role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent diff --git a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml index f81e6e42633..0f05fd7ae20 100644 --- a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml +++ b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetails.yml @@ -2,6 +2,7 @@ GetAllTxnDetailBulkUpload: master_GetAllTxnDetailBulkUpload_Smoke: endPoint: /v1/admin/bulkupload/getAllTransactions role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetAllTxnDetailBulkUpload/allTxnDetails outputTemplate: masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult diff --git a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml index fe68d18252f..b9a40d51058 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml +++ b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigs.yml @@ -2,14 +2,12 @@ GetCredentialTypes: master_GetApplicationConfigs_smoke: endPoint: /v1/masterdata/applicationconfigs role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/GetApplicationConfigs/getApplicationConfigs outputTemplate: masterdata/GetApplicationConfigs/getApplicationConfigsResult input: '{ }' output: '{ - "response": { - "primaryLangCode": "eng", - "secondaryLangCode": "ara" - } + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml b/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml index c1474690a27..1bd70ed17fc 100644 --- a/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml +++ b/automationtests/src/main/resources/masterdata/HolidaySearch/HolidaySearch.yml @@ -28,7 +28,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", @@ -36,7 +35,6 @@ HolidaySearch: "holidayName": "AutoTest user Eng", "holidayDesc": "$IGNORE$", "langCode": "eng" - }] }' MasterData_HolidaySearch_equals_holidayName_ara_pos: endPoint: /v1/masterdata/holidays/search @@ -67,7 +65,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", @@ -75,7 +72,6 @@ HolidaySearch: "holidayName": "AutoTest user Ara", "holidayDesc": "$IGNORE$", "langCode": "ara" - }] }' MasterData_HolidaySearch_startsWith_holidayName_eng_pos: endPoint: /v1/masterdata/holidays/search @@ -106,7 +102,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", @@ -114,7 +109,6 @@ HolidaySearch: "holidayName": "AutoTest user Eng", "holidayDesc": "$IGNORE$", "langCode": "eng" - }] }' MasterData_HolidaySearch_startsWith_holidayName_ara_pos: endPoint: /v1/masterdata/holidays/search @@ -145,7 +139,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", @@ -153,7 +146,6 @@ HolidaySearch: "holidayName": "AutoTest user Ara", "holidayDesc": "$IGNORE$", "langCode": "ara" - }] }' MasterData_HolidaySearch_contains_holidayName_eng_pos: endPoint: /v1/masterdata/holidays/search @@ -184,7 +176,6 @@ HolidaySearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "isActive": $IGNORE$, "holidayId": "$IGNORE$", "name": "$IGNORE$", @@ -192,7 +183,6 @@ HolidaySearch: "holidayName": "$IGNORE$", "holidayDesc": "$IGNORE$", "langCode": "eng" - }] }' diff --git a/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml b/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml index f74e8f199c6..6c7dd4caa12 100644 --- a/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml +++ b/automationtests/src/main/resources/masterdata/Machine/CreateMachine.yml @@ -236,16 +236,12 @@ CreateMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "id":"$IGNORE$", - "name": "HMT", - "machineSpecId": "1001", - "serialNum":"FB5962911687", - "ipAddress": "192.168.0.424", - "isActive": "$IGNORE$", - "langCode": "eng", - "macAddress": "$IGNORE$", - "zoneCode": "CST", - "validityDateTime": "$IGNORE$" + "errors": [ + { + "errorCode": "KER-MSD-255", + "message": "Admin not authorized to access this Machine for this Zone" + } + ] }' Masterdata_CreateMachine_inValid_MachineName_AboveMaxLen64: endPoint: /v1/masterdata/machines diff --git a/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml b/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml index e7fc97ab32b..8297965b4d2 100644 --- a/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml +++ b/automationtests/src/main/resources/masterdata/Machine/UpdateMachine.yml @@ -206,16 +206,12 @@ UpdateMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "id":"$IGNORE$", - "name": "HMT", - "machineSpecId": "1001", - "serialNum":"FB5962911687", - "ipAddress": "192.168.0.424", - "isActive": "$IGNORE$", - "langCode": "$IGNORE$", - "macAddress": "$IGNORE$", - "zoneCode": "CST", - "validityDateTime": "$IGNORE$" + "errors": [ + { + "errorCode": "KER-MSD-255", + "message": "Admin not authorized to access this Machine for this Zone" + } + ] }' Masterdata_UpdateMachine_inValid_MachineName_AboveMaxLen64: endPoint: /v1/masterdata/machines diff --git a/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml b/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml index bae49bdfdd2..a4c3ef373c8 100644 --- a/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml +++ b/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml @@ -42,6 +42,7 @@ MachineTypeSearch: Masterdata_MachineTypeSearch_withoutfilterValue_eng: endPoint: /v1/masterdata/machinetypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/MachineTypeSearch/machineTypeSearch diff --git a/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml b/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml index 66ffb1943c1..8f3173b95eb 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml +++ b/automationtests/src/main/resources/masterdata/RegCenterType/UpdateRegCenterType.yml @@ -118,7 +118,7 @@ UpdateRegCenterType: templateFields: ["name","descr"] restMethod: put inputTemplate: masterdata/RegCenterType/regCenterType - outputTemplate: masterdata/error + outputTemplate: masterdata/RegCenterType/regCenterTypeResult input: '{ "code": "ALT-3", "langCode": "eng", diff --git a/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml b/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml index 8735f6fa29c..d4814e6e1b1 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml +++ b/automationtests/src/main/resources/masterdata/SearchDocCategories/SearchDocCategories.yml @@ -190,6 +190,7 @@ SearchDocCategories: MasterData_SearchDocCategories_inValid_filter_value: endPoint: /v1/masterdata/documentcategories/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchDocCategories/searchDocCategories diff --git a/automationtests/src/main/resources/masterdata/SearchDocumentType/SearchDocumentType.yml b/automationtests/src/main/resources/masterdata/SearchDocumentType/SearchDocumentType.yml index 755c05b916c..ac66153aed3 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocumentType/SearchDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/SearchDocumentType/SearchDocumentType.yml @@ -191,6 +191,7 @@ SearchDocumentType: MasterData_SearchDocumentType_inValid_filter_value: endPoint: /v1/masterdata/documenttypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/SearchDocumentType/searchDocumentType diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml index 50330d3da85..7719616787f 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachine/SearchMachine.yml @@ -28,7 +28,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -39,7 +38,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_FilterTypeContains: endPoint: /v1/masterdata/machines/search @@ -70,7 +68,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -81,7 +78,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_FilterTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -112,7 +108,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "NLT updated", "serialNum": "FB5962911687", @@ -123,7 +118,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNFilterTypeEquals: endPoint: /v1/masterdata/machines/search @@ -154,7 +148,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -165,7 +158,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNTypeContains: endPoint: /v1/masterdata/machines/search @@ -196,7 +188,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -207,7 +198,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnMacAddressNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -238,7 +228,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -249,7 +238,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeEquals: endPoint: /v1/masterdata/machines/search @@ -280,7 +268,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -291,7 +278,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeContains: endPoint: /v1/masterdata/machines/search @@ -322,7 +308,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -333,7 +318,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnSerialNumberNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -364,7 +348,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -375,7 +358,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeEquals: endPoint: /v1/masterdata/machines/search @@ -406,7 +388,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -417,7 +398,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeContains: endPoint: /v1/masterdata/machines/search @@ -448,7 +428,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -459,7 +438,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_ColumnMachineSpecIdNTypeStartsWith: endPoint: /v1/masterdata/machines/search @@ -490,7 +468,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -501,7 +478,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_TwoFilterValues_TypeEqualsNEquals: endPoint: /v1/masterdata/machines/search @@ -539,7 +515,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -550,7 +525,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_SortFieldDESC: endPoint: /v1/masterdata/machines/search @@ -581,7 +555,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -592,7 +565,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_TwoSortFields_DescNDesc: endPoint: /v1/masterdata/machines/search @@ -627,7 +599,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "$IGNORE$", "serialNum": "FB5962911687", @@ -638,7 +609,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Valid_TwoSortFields_AscNDesc: endPoint: /v1/masterdata/machines/search @@ -673,7 +643,6 @@ SearchMachine: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "Mach-Test", "serialNum": "FB5962911687", @@ -684,7 +653,6 @@ SearchMachine: "zoneCode": "CST", "zone": "$IGNORE$", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachine_Invalid_ColumnName: endPoint: /v1/masterdata/machines/search diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml index 9bd090ed910..504034e147c 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml @@ -28,7 +28,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -38,7 +37,6 @@ SearchMachineSpec: "description": "HP brand", "langCode": "eng", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachineSpec_Valid_sortType_DESC: endPoint: /v1/masterdata/machinespecifications/search @@ -67,7 +65,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -77,7 +74,6 @@ SearchMachineSpec: "description": "HP brand", "langCode": "eng", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachineSpec_Valid_col_as_Model: endPoint: /v1/masterdata/machinespecifications/search @@ -106,7 +102,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -116,7 +111,6 @@ SearchMachineSpec: "description": "HP brand", "langCode": "eng", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachineSpec_Valid_col_as_Brand: endPoint: /v1/masterdata/machinespecifications/search @@ -184,7 +178,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -194,7 +187,6 @@ SearchMachineSpec: "description": "HP brand", "langCode": "eng", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachineSpec_Valid_col_as_Name_FltrTyp_startsWith: endPoint: /v1/masterdata/machinespecifications/search @@ -223,7 +215,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -233,7 +224,6 @@ SearchMachineSpec: "description": "HP brand", "langCode": "eng", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachineSpec_Valid_col_as_Name_FltrTyp_contains: endPoint: /v1/masterdata/machinespecifications/search @@ -262,7 +252,6 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -272,7 +261,6 @@ SearchMachineSpec: "description": "HP brand", "langCode": "eng", "isActive": $IGNORE$ - }] }' Masterdata_SearchMachineSpec_inValid_columnName_blank: endPoint: /v1/masterdata/machinespecifications/search @@ -575,7 +563,7 @@ SearchMachineSpec: output: '{ "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "KER-MSD-313", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml index cf41df601e1..d9dcfcfd99c 100644 --- a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml +++ b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/UpdateBlockListedWordDetails.yml @@ -54,8 +54,12 @@ UpdateBlockListedWordDetails: "requesttime": "$TIMESTAMP$" }' output: '{ - "word": "bullword", - "langCode": "eng" + "errors": [ + { + "errorCode": "KER-MSD-008", + "message": "Blocklisted word not found" + } + ] }' Masterdata_CreateBlockListedWords_Invalid_DescriptionLength257: endPoint: /v1/masterdata/blocklistedwords/details diff --git a/automationtests/src/main/resources/masterdata/error.hbs b/automationtests/src/main/resources/masterdata/error.hbs index 4b6b655b4e3..04f0f8e99d2 100644 --- a/automationtests/src/main/resources/masterdata/error.hbs +++ b/automationtests/src/main/resources/masterdata/error.hbs @@ -6,7 +6,7 @@ {{#each errors}} { "errorCode": "{{errorCode}}", - "message": "{{message}}" + "message": "$IGNORE$" } {{#unless @last}},{{/unless}} {{/each}} From 923c42dfac7b4ea8fea2275dca1ec73d73456688 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Thu, 10 Aug 2023 13:31:06 +0530 Subject: [PATCH 025/204] adding local changes --- .../apirig/admin/fw/util/AdminTestUtil.java | 21 ++++++++++ .../apirig/testrunner/MosipTestRunner.java | 2 + .../main/resources/config/Kernel.properties | 40 +++++++++---------- .../resources/config/application.properties | 3 +- 4 files changed, 45 insertions(+), 21 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 416cebf4557..f60f5cf954e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4941,5 +4941,26 @@ public static String getCommitDetails(String path) { } return path + "- No Response"; } + + public static String getLocationData() { + + Response response = null; + JSONObject responseJson = null; + String url = ApplnURI + props.getProperty("fetchLocationData"); + String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); + String waitInterval = null; + try { + response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token, IDTOKENCOOKIENAME, idToken); + + responseJson = new JSONObject(response.getBody().asString()); + + + return waitInterval; + } catch (Exception e) { + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); + return waitInterval; + } + } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 2af7dfc7c10..c843a2a5ecc 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -77,6 +77,8 @@ public static void main(String[] arg) { } KeycloakUserManager.removeUser(); KeycloakUserManager.createUsers(); + + AdminTestUtil.getLocationData(); String partnerKeyURL = ""; diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 9948c42092c..6083afa61d4 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -109,43 +109,43 @@ partner_user_password=mosip123 mosip_pms_client_id=mosip-pms-client mosip_partner_client_id=mosip-partner-client mosip_partner_client_secret=abc123 -mosip_pms_client_secret=abc123 +mosip_pms_client_secret=Tkx3jw9INusggEDW policytest_password=mosip123 policytest_userName=111998 #RESIDENT & IDA mosip_resident_app_id=resident mosip_resident_client_id=mosip-resident-client -mosip_resident_client_secret=abc123 +mosip_resident_client_secret=UGq78khkAst6fjbn #IDREPO mosip_idrepo_app_id=idrepo mosip_idrepo_client_id=mosip-idrepo-client -mosip_idrepo_client_secret=abc123 +mosip_idrepo_client_secret=wJ21F8gXzdy2RM9q #admin mosip_admin_app_id=admin admin_password=mosip123 admin_userName=220005 mosip_admin_client_id=mosip-admin-client -mosip_admin_client_secret=xyz123 +mosip_admin_client_secret=7Vvj405Z5a35eAod #admin admin_zone_password=mosip123 admin_zone_userName=globaladmin mosip_regclient_app_id=registrationclient mosip_reg_client_id=mosip-reg-client -mosip_reg_client_secret=abc123 +mosip_reg_client_secret=SGqovDBMh7McnAxw #admin mosip_regprocclient_app_id=regproc mosip_regproc_client_id=mosip-regproc-client -mosip_regproc_client_secret=abc123 +mosip_regproc_client_secret=lntJVPztZAOYpmTR #mparter_mobile mpartner_default_mobile_client_id=mpartner-default-mobile -mpartner_default_mobile_secret=3adc8ff6-29a1-4149-9193-21752eb2f07a +mpartner_default_mobile_secret=Gif10hl5sFH6WCUi #This credentials are used to execute auth demo service AuthClientID=mosip-resident-client -AuthClientSecret=abc123 +AuthClientSecret=UGq78khkAst6fjbn AuthAppID=resident mosip_hotlist_app_id=hotlist mosip_hotlist_client_id=mosip-hotlist-client @@ -160,11 +160,11 @@ roles.111995=PARTNER_ADMIN,default-roles-mosip keycloak_UserName = admin -keycloak_Password = admin +keycloak_Password = oY6ijJuIL8 -keycloak-external-url=https://qa-115.mosip.net/keycloak +keycloak-external-url=https://iam.dev3.mosip.net mosip_testrig_client_id=mosip-testrig-client -mosip_testrig_client_secret=abc123 +mosip_testrig_client_secret=aOCfcQC2dYm2Iotg keycloak-realm-id=mosip iam-users-to-create=111997,111998,220005,111992,globaladmin @@ -182,14 +182,14 @@ dialect=org.hibernate.dialect.PostgreSQLDialect show_sql=true current_session_context_class=thread #audit details -audit_url=jdbc:postgresql://qa-115.mosip.net:5432/mosip_audit +audit_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_audit audit_username=postgres audit_password=rLqRHeY4C5 audit_default_schema=audit #ida-partner details DB_PORT= installation-domain= -partner_url=jdbc:postgresql://qa-115.mosip.net:5432/mosip_ida +partner_url=jdbc:postgresql://dev3.mosip.net:5432/mosip_ida partner_username=postgres partner_password=rLqRHeY4C5 partner_default_schema=partner @@ -202,7 +202,7 @@ s3-account=automation s3-region=null reportExpirationInDays=3 # supported values yes or no -push-reports-to-s3=yes +push-reports-to-s3=no enableDebug=no # supported values are 1 to 8 threadCount=1 @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -#authDemoServiceBaseURL=http://localhost -#authDemoServicePort=8082 +authDemoServiceBaseURL=http://localhost +authDemoServicePort=8082 #To run in Docker -authDemoServiceBaseURL=http://authdemo.apitestrig -authDemoServicePort=80 +#authDemoServiceBaseURL=http://authdemo.apitestrig +#authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# @@ -248,10 +248,10 @@ auditActuatorEndpoint=/v1/auditmanager/actuator/info validateBindingEndpoint=ida-binding #To run in Docker -authCertsPath=/home/mosip/authcerts +#authCertsPath=/home/mosip/authcerts #To run locally -#authCertsPath= +authCertsPath= preconfiguredOtp=111111 usePreConfiguredOtp=true diff --git a/automationtests/src/main/resources/config/application.properties b/automationtests/src/main/resources/config/application.properties index ce90c4774f7..0b5915f6f8d 100644 --- a/automationtests/src/main/resources/config/application.properties +++ b/automationtests/src/main/resources/config/application.properties @@ -72,4 +72,5 @@ mimotoAutoGeneratedIdPropFileName=/mimoto/autoGeneratedId.properties authAutoGeneratedIdPropFileName=/ida/autoGeneratedId.properties prerequisiteAutoGeneratedIdPropFileName=/prerequisite/autoGeneratedId.properties regProcAutoGeneratedIdPropFileName=/regProc/autoGeneratedId.properties -mobileIdAutoGeneratedIdPropFileName=/mobileId/autoGeneratedId.properties \ No newline at end of file +mobileIdAutoGeneratedIdPropFileName=/mobileId/autoGeneratedId.properties +fetchLocationData=/v1/masterdata/locations/all \ No newline at end of file From cb95a68a39a885f522d7d116dbf2e9dc218570d4 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 10 Aug 2023 16:20:41 +0530 Subject: [PATCH 026/204] MOSIP-28895 --- .../apirig/admin/fw/util/TestJava.java | 94 ++----------- .../idRepository/CreateDraft/CreateDraft.yml | 7 +- .../DeactivateVid/DeactivateVid.yml | 9 +- .../PublishDraft/PublishDraft.yml | 7 +- .../ReactivateVIDsForUIN.yml | 7 +- .../RetrieveAuthTypeStatus.yml | 28 +++- .../RetrieveIdentityByRid.yml | 3 +- .../retrieveIdentityByRidResult.hbs | 131 +----------------- .../RetrieveIdentityByUin.yml | 3 + .../RetrieveVIDByUIN/RetrieveVIDByUIN.yml | 11 +- .../UpdateIdentity/UpdateIdentity.yml | 2 +- .../UpdateVIDStatus/UpdateVidStatus.yml | 4 +- .../UpdateVIDStatus/UpdateVidStatusResult.hbs | 23 +-- 13 files changed, 81 insertions(+), 248 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java index 4315947f147..1e824613b2b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java @@ -21,92 +21,18 @@ public class TestJava { private static final Logger lOGGER = Logger.getLogger(TestJava.class); private static final SecureRandom secureRandom = new SecureRandom(); - public static void main(String[] args) { - int num = 1011111; - JsonToCsvConverter("E:\\scenarios.json"); + public static void main(String[] args) { + String string = "e2e_getPingHealth(packetcreator)"; + Pattern pattern = Pattern.compile("(.*?)\\((.*?),(.*)\\)"); + Matcher matcher = pattern.matcher(string); + if (matcher.matches()) { + System.out.println("The string contains a comma between parentheses"); + } else { + System.out.println("The string does not contain a comma between parentheses"); + } + } -// String transactionID = (num + AdminTestUtil.generateRandomNumberString(8)).substring(0, 10); -// lOGGER.info(transactionID); -// -// Pattern mPattern = Pattern.compile("(|^)\\s\\d{6}\\s"); -// -// String message = "Dear FR OTP for VID XXXXXXXX65185914 is 333333 and is valid for 3 minutes. (Generated on 21-03-2023 at 16:03:54 Hrs)\r\n" -// + "عزيزي $ name OTP لـ $ idvidType $ idvid هو $ otp وهو صالح لـ $ validTime دقيقة. (تم إنشاؤه في $ date في $ time Hrs)\r\n" -// + "Cher $name_fra, OTP pour VID XXXXXXXX65185914 est 111111 et est valide pour 3 minutes. (Généré le 21-03-2023 à 16:03:54 Hrs)"; -// -// message = "Dear TEST_FULLNAMEeng OTP for UIN XXXXXXXX98 is 523478 and is valid for 3 minutes. (Generated on 22-05-2023 at 11:40:11 Hrs) عزيزي $ name OTP لـ $ idvidType $ idvid هو $ otp وهو صالح لـ $ validTime دقيقة. (تم إنشاؤه في $ date في $ time Hrs) UIN XXXXXXXX98 ಗಾಗಿ ಆತ್ಮೀಯ TEST_FULLNAMEkan OTP 523478 ಆಗಿದೆ ಮತ್ತು ಇದು 3 ನಿಮಿಷಗಳವರೆಗೆ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ. (22-05-2023 ದಂದು 11:40:11 ಗಂಟೆಗೆ ರಚಿಸಲಾಗಿದೆ)"; -// -// if(message!=null) { -// Matcher mMatcher = mPattern.matcher(message); -// if(mMatcher.find()) { -// String otp = mMatcher.group(0); -// otp = otp.trim(); -// lOGGER.info("Final OTP: "+ otp); -// }else { -// lOGGER.info("Failed to extract the OTP!! "); -// } -// } - } - public static String JsonToCsvConverter(String jsonFilePath) { - String tempCSVPath = "E:\\scenarios.csv"; - try { - ObjectMapper objectMapper = new ObjectMapper(); - JsonNode rootNode = objectMapper.readTree(new File(jsonFilePath)); - - FileWriter fileWriter = new FileWriter(tempCSVPath); - String[] header = { "tc_no", "tags", "persona_class", "persona", "group_name", "description", "step0", - "step1", "step2", "step3", "step4", "step5", "step6", "step7", "step8", "step9", "step10", "step11", - "step12", "step13", "step14", "step15", "step16", "step17", "step18", "step19", "step20", "step21", - "step22", "step23", "step24", "step25", "step26", "step27", "step28", "step29", "step30", "step31", - "step32", "step33", "step34", "step35", "step36", "step37", "step38", "step39", "step40", "step41", - "step42", "step43", "step44", "step45", "step46", "step47", "step48", "step49", "step50" }; - for (String string : header) { - fileWriter.write(string + ","); - } - fileWriter.write("\r\n"); - for (JsonNode jsonNode : rootNode) { - String[] csvLine = { jsonNode.get("tc_no").asText(), jsonNode.get("tags").asText(), - jsonNode.get("persona_class").asText(), jsonNode.get("persona").asText(), - jsonNode.get("group_name").asText(), jsonNode.get("description").asText(), - jsonNode.get("step0") == null ? "" : "\"" + jsonNode.get("step0").asText() + "\"", - jsonNode.get("step1") == null ? "" : "\"" + jsonNode.get("step1").asText() + "\"", - jsonNode.get("step2") == null ? "" : "\"" + jsonNode.get("step2").asText() + "\"", - // ... continue for other fields ... - jsonNode.get("step49") == null ? "" : "\"" + jsonNode.get("step49").asText() + "\"", - jsonNode.get("step50") == null ? "" : "\"" + jsonNode.get("step50").asText() + "\"" }; - for (String string : csvLine) { - fileWriter.write(string + ","); - } - fileWriter.write("\r\n"); - } - fileWriter.close(); - } catch (Exception e) { - - } - return tempCSVPath; - } - - public static String generateRandomAlphanumericString(int length) { - byte[] bytes = new byte[length]; - secureRandom.nextBytes(bytes); - String randomString = new String(bytes); - return randomString.replaceAll("[^0-9a-zA-Z]", ""); - } - - public static String generateRandomString(int length) { - byte[] bytes = new byte[length]; - secureRandom.nextBytes(bytes); - String randomString = new String(bytes); - return randomString; - } - - public static String generateRandomNumericString(int length) { - byte[] bytes = new byte[length]; - secureRandom.nextBytes(bytes); - String randomString = new String(bytes); - return randomString.replaceAll("[^0-9]", ""); - } } diff --git a/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml b/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml index 4e1bcc90663..0fa957da49a 100644 --- a/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml +++ b/automationtests/src/main/resources/idRepository/CreateDraft/CreateDraft.yml @@ -21,7 +21,12 @@ CreateDraft: "registrationId":"$RID$" }' output: '{ - "message": "Record already exists in DB" + "errors": [ + { + "errorCode": "IDR-IDC-012", + "message": "Record already exists in DB" + } + ] }' IdRepository_CreateDraft_delete_Smoke_Pos: endPoint: /idrepository/v1/identity/draft/create/{registrationId} diff --git a/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml b/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml index ea76073da2e..e5178a523e5 100644 --- a/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml +++ b/automationtests/src/main/resources/idRepository/DeactivateVid/DeactivateVid.yml @@ -20,7 +20,7 @@ DeactivateVIDs: role: resident restMethod: post inputTemplate: idRepository/DeactivateVid/deactivateVid - outputTemplate: idRepository/DeactivateVid/deactivateVidResult + outputTemplate: idRepository/error input: '{ "UIN": "$ID:AddIdentity_For_DeactivateScen_smoke_Pos_UIN$", "requesttime": "$TIMESTAMP$", @@ -28,7 +28,12 @@ DeactivateVIDs: "version": "v1" }' output: '{ - "vidStatus": "DEACTIVATED" + "errors": [ + { + "errorCode": "IDR-IDC-007", + "message": "No Record(s) found" + } + ] }' IdRepository_DeactivateVIDs_Onetime_Smoke_Pos: diff --git a/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml b/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml index b29692ef4d4..9d83b9881ef 100644 --- a/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml +++ b/automationtests/src/main/resources/idRepository/PublishDraft/PublishDraft.yml @@ -11,7 +11,7 @@ PublishDraft: output: '{ "status": "ACTIVATED" }' - IdRepository_RePublishDraft_valid_smoke: + IdRepository_RePublishDraft_Invalid_Neg: endPoint: /idrepository/v1/identity/draft/publish/{registrationId} role: idrepo restMethod: get @@ -21,5 +21,10 @@ PublishDraft: "registrationId":"$RID$" }' output: '{ + "errors": [ + { + "errorCode": "IDR-IDC-007", "message": "No Record(s) found" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml b/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml index 29a1b10ac46..e501fa2f6b8 100644 --- a/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml +++ b/automationtests/src/main/resources/idRepository/ReactivateVIDsForUIN/ReactivateVIDsForUIN.yml @@ -28,7 +28,12 @@ ReactivateVIDs: "version": "v1" }' output: '{ - "vidStatus": "ACTIVE" + "errors": [ + { + "errorCode": "IDR-IDC-007", + "message": "No Record(s) found" + } + ] }' IdRepository_ReactivateVIDs_Onetime_Smoke_Pos: diff --git a/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml b/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml index d5d0f36de05..ecd675d554c 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveAuthTypeStatus/RetrieveAuthTypeStatus.yml @@ -39,7 +39,12 @@ RetrieveAuthTypeStatus: "ID": "kajnfajk" }' output: '{ - + "errors": [ + { + "errorCode": "IDR-IDC-004", + "message": "Unknown error occurred" + } + ] }' IdRepository_RetrieveAuthTypeStatus_Uin_Empty_Id_Neg: @@ -70,7 +75,12 @@ RetrieveAuthTypeStatus: "ID": " " }' output: '{ - + "errors": [ + { + "errorCode": "IDR-IDC-004", + "message": "Unknown error occurred" + } + ] }' IdRepository_RetrieveAuthTypeStatus_Vid_Invalid_Id_Neg: @@ -83,7 +93,12 @@ RetrieveAuthTypeStatus: "ID": "kajnfajk" }' output: '{ - + "errors": [ + { + "errorCode": "IDR-IDC-004", + "message": "Unknown error occurred" + } + ] }' IdRepository_RetrieveAuthTypeStatus_Vid_Empty_Id_Neg: @@ -114,5 +129,10 @@ RetrieveAuthTypeStatus: "ID": " " }' output: '{ - + "errors": [ + { + "errorCode": "IDR-IDC-004", + "message": "Unknown error occurred" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml index df3f6f57318..ca6e7bb3da8 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/RetrieveIdentityByRid.yml @@ -1,5 +1,5 @@ RetrieveIdentityByRid: - IdRepository_RetrieveIdentityByRid_With_Valid Smoke_Rid: + IdRepository_RetrieveIdentityByRid_With_Valid_Smoke_Rid: endPoint: /idrepository/v1/identity/idvid/{RID} role: idrepo restMethod: get @@ -9,7 +9,6 @@ RetrieveIdentityByRid: "RID":"$ID:AddIdentity_withValidParameters_smoke_Pos_RID$" }' output: '{ - "vidStatus": "ACTIVATED" }' IdRepository_RetrieveIdentityByRid_Invalid_Rid_Neg: diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs index adb061b1387..1e374a74f1c 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByRid/retrieveIdentityByRidResult.hbs @@ -5,135 +5,8 @@ "metadata": null, "response": { "status": "ACTIVATED", - "identity": { - "residenceStatus": [ - { - "language": "eng", - "value": "FR" - } - ], - "IDSchemaVersion": 0.1, - "UIN": $IGNORE$, - "fullName": [ - { - "language": "eng", - "value": "TestQA" - } - ], - "dateOfBirth": "1992/04/15", - "gender": [ - { - "language": "eng", - "value": "Male" - }, - { - "language": "ara", - "value": "الذكر" - } - ], - "addressLine1": [ - { - "language": "eng", - "value": "exemple d'adresse ligne 1" - } - ], - "addressLine2": [ - { - "language": "eng", - "value": "exemple d'adresse ligne 2" - } - ], - "addressLine3": [ - { - "language": "eng", - "value": "exemple d'adresse ligne 2" - } - ], - "region": [ - { - "language": "eng", - "value": "RSK" - } - ], - "province": [ - { - "language": "eng", - "value": "Kenitra" - } - ], - "city": [ - { - "language": "eng", - "value": "Kenitra" - } - ], - "postalCode": "14022", - "phone": "8553967572", - "email": "mosipuser123@mailinator.com", - "referenceIdentityNumber": "6789545678878", - "zone": [ - { - "language": "eng", - "value": "QRHS" - } - ], - "parentOrGuardianRID": "212124324784879", - "parentOrGuardianUIN": "212124324784879", - "parentOrGuardianName": [ - { - "language": "ara", - "value": "سلمى" - }, - { - "language": "eng", - "value": "salma" - } - ], - "proofOfAddress": { - "format": "pdf", - "type": "RNC", - "value": "fileReferenceID" - }, - "proofOfIdentity": { - "format": "txt", - "type": "DOC001", - "value": "fileReferenceID" - }, - "proofOfRelationship": { - "format": "pdf", - "type": "DOC001", - "value": "fileReferenceID" - }, - "proofOfDateOfBirth": { - "format": "pdf", - "type": "passport", - "value": "fileReferenceID" - }, - "individualBiometrics": { - "format": "cbeff", - "version": 1, - "value": "fileReferenceID" - }, - "parentOrGuardianBiometrics": { - "format": "cbeff", - "version": 1.1, - "value": "fileReferenceID" - } - }, - "documents": [ - { - "category": "individualBiometrics", - "value": "$IGNORE$" - }, - { - "category": "proofOfDateOfBirth", - "value": "dGVzdA" - }, - { - "category": "proofOfRelationship", - "value": "dGVzdA" - } - ] + "identity": "$IGNORE$", + "documents": "$IGNORE$" }, "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml index ee8288ed68b..b070d11d1a5 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveIdentityByUin/RetrieveIdentityByUin.yml @@ -2,6 +2,7 @@ RetrieveIdentity: IdRepository_RetrieveIdentity_With_Valid_UIN_Smoke_Pos: endPoint: /idrepository/v1/identity/idvid/{id} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveIdentityByUin/retrieveIdentityByUin outputTemplate: idRepository/error @@ -15,6 +16,7 @@ RetrieveIdentity: IdRepository_RetrieveIdentity_With_Deactivated_UIN_Smoke_Pos: endPoint: /idrepository/v1/identity/idvid/{id} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveIdentityByUin/retrieveIdentityByUin outputTemplate: idRepository/error @@ -28,6 +30,7 @@ RetrieveIdentity: IdRepository_RetrieveIdentity_With_Valid_Vid_Smoke_Pos: endPoint: /idrepository/v1/identity/idvid/{id} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveIdentityByUin/retrieveIdentityByUin outputTemplate: idRepository/error diff --git a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml index 5c07d770a81..338158a1855 100644 --- a/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml +++ b/automationtests/src/main/resources/idRepository/RetrieveVIDByUIN/RetrieveVIDByUIN.yml @@ -1,7 +1,8 @@ RetrieveVIDByUIN: - IdRepository_RetrieveVIDByUIN_With_Valid Smoke_Temp: + IdRepository_RetrieveVIDByUIN_With_Valid_Smoke_Temp: endPoint: /idrepository/v1/vid/uin/{UIN} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUIN outputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult @@ -9,11 +10,11 @@ RetrieveVIDByUIN: "UIN":"$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$" }' output: '{ - "vidType": "TEMPORARY" }' - IdRepository_RetrieveVIDByUIN_With_Valid Smoke_Perp: + IdRepository_RetrieveVIDByUIN_With_Valid_Smoke_Perp: endPoint: /idrepository/v1/vid/uin/{UIN} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUIN outputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult @@ -21,12 +22,12 @@ RetrieveVIDByUIN: "UIN":"$ID:AddIdentity_ValidParam_smoke_Pos_UIN$" }' output: '{ - "vidType": "PERPETUAL" }' - IdRepository_RetrieveVIDByUIN_With_All_Vid_Valid Smoke: + IdRepository_RetrieveVIDByUIN_With_All_Vid_Valid_Smoke: endPoint: /idrepository/v1/vid/uin/{UIN} role: idrepo + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUIN outputTemplate: idRepository/RetrieveVIDByUIN/retrieveVIDByUINResult diff --git a/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml b/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml index 4a11aec09b4..2ada083e1ef 100644 --- a/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml +++ b/automationtests/src/main/resources/idRepository/UpdateIdentity/UpdateIdentity.yml @@ -282,7 +282,7 @@ UpdateIdentity: "errors": [ { "errorCode": "IDR-IDC-001", - "message": "Missing Input Parameter - registrationId" + "message": "$IGNORE$" } ] }' diff --git a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml index c27adafe43a..931e31936c0 100644 --- a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml +++ b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatus.yml @@ -167,7 +167,7 @@ UpdateVidStatus: } ] }' - IdRepository_UpdateVidStatus_withVidStatus_USED_For Vid Type_Perpetual: + IdRepository_UpdateVidStatus_withVidStatus_USED_For_Vid Type_Perpetual: endPoint: /idrepository/v1/vid/{VID} role: idrepo restMethod: PATCH @@ -181,7 +181,7 @@ UpdateVidStatus: "requesttime": "$TIMESTAMP$" }' output: '{ - "vidStatus": "USED" + "vidStatus": "ACTIVE" }' IdRepository_UpdateVidStatus_withInvalidversion_ForVidType_Perpetual: endPoint: /idrepository/v1/vid/{VID} diff --git a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs index 574a946ee08..6a2647327e5 100644 --- a/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs +++ b/automationtests/src/main/resources/idRepository/UpdateVIDStatus/UpdateVidStatusResult.hbs @@ -1,18 +1,9 @@ { - "id": "mosip.vid.update", - "version": "v1", - "responsetime": "$IGNORE$", - "metadata": null, - "response": { - "vidStatus": "{{vidStatus}}", - "restoredVid": { - "vidStatus": "$IGNORE$", - "restoredVid": $IGNORE$, - "UIN": $IGNORE$, - "VID": "$IGNORE$" - }, - "UIN": null, - "VID": null - }, - "errors": [] + "id": "$IGNORE$", + "version": "$IGNORE$", + "responsetime": "$IGNORE$", + "response": { + "vidStatus": "{{vidStatus}}" + }, + "errors": [] } \ No newline at end of file From 8799e60707148f679222283e104768f9b61fbc09 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 10 Aug 2023 18:44:14 +0530 Subject: [PATCH 027/204] MOSIP-28903 --- .../testrig/apirig/global/utils/GlobalMethods.java | 7 ++++++- .../AidGetIndividualId/AidGetIndividualId.yml | 14 ++++++++++++-- .../resources/mobileId/BindingOtp/BindingOtp.yml | 1 + .../mobileId/GenerateVID/createGenerateVID.yml | 8 ++++++-- 4 files changed, 25 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java index a0ff3a8ca24..ce8f5ece073 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/global/utils/GlobalMethods.java @@ -8,7 +8,12 @@ public class GlobalMethods { public static void reportRequest(String request) { - Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + ReportUtil.getTextAreaJsonMsgHtml(request == null ? "No request body" : request)); + if(request!=null) + Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + ReportUtil.getTextAreaJsonMsgHtml(request) + + GlobalConstants.REPORT_REQUEST_SUFFIX); + else + Reporter.log(GlobalConstants.REPORT_REQUEST_PREFIX + "Empty Input" + + GlobalConstants.REPORT_REQUEST_SUFFIX); } public static void reportResponse(String url, Response response) { diff --git a/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml b/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml index ec7dbcbaa12..176db703232 100644 --- a/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml +++ b/automationtests/src/main/resources/mobileId/AidGetIndividualId/AidGetIndividualId.yml @@ -43,7 +43,12 @@ AidGetIndividualId: } }' output: '{ - "transactionID": "$TRANSACTIONID$", + "errors": [ + { + "errorCode": "RES-SER-457", + "errorMessage": "AID not found" + } + ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", @@ -69,7 +74,12 @@ AidGetIndividualId: } }' output: '{ - "transactionID": "$TRANSACTIONID$", + "errors": [ + { + "errorCode": "RES-SER-422", + "errorMessage": "OTP is invalid" + } + ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTPUIN/individualIdOtpResult", diff --git a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml index 3aac2c6362a..947b4bcf2c5 100644 --- a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml +++ b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml @@ -2,6 +2,7 @@ BindingOtp: MobileId_BindingOtp_Valid_UIN_All_Smoke: endPoint: /residentmobileapp/binding-otp role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: mobileId/BindingOtp/BindingOtp diff --git a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml index 7019a639b32..079389af775 100644 --- a/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/mobileId/GenerateVID/createGenerateVID.yml @@ -151,8 +151,12 @@ GenerateVID: } }' output: '{ - "vid": "$IGNORE$", - "message": "Notification has been sent to the provided contact detail(s)", + "errors": [ + { + "errorCode": "RES-SER-422", + "errorMessage": "Invalid Input Parameter - transactionID" + } + ], "sendOtpResp":{ "maskedMobile": "XXXXXX3210", "sendOtpResTemplate":"mobileId/SendOTP/createSendOTPResult", From 5d8c1ba8ca57b3b853449f81eb414647053eaa25 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 11 Aug 2023 17:27:13 +0530 Subject: [PATCH 028/204] MOSIP-28917 --- .../fw/util/OutputValidationUtil.java | 12 +++- .../DeviceDetailsFilter.yml | 8 --- .../DeviceSubTypeFilter.yml | 8 --- .../ServiceToFilterSBI/ServiceToFilterSBI.yml | 8 --- .../FtpPartner/UploadCert/UploadCert.yml | 2 +- .../GetAllPolicyGroup/GetAllPolicyGroup.yml | 15 +---- .../getPartnersPolicyResult.hbs | 25 +------- .../createSearchDeviceDetails.yml | 10 +-- .../SearchPartner/createSearchPartner.yml | 19 +++--- .../createSearchPolicyGroup.yml | 63 ++----------------- .../authPartner/GetCertificate/GetCert.yml | 2 +- .../authPartner/UploadCert/UploadCert.yml | 4 +- .../GetCertificate/GetCert.yml | 1 + .../UploadCert/UploadCert.yml | 2 +- .../devicePartner/GetCertificate/GetCert.yml | 1 + .../devicePartner/UploadCert/UploadCert.yml | 2 +- .../mispPartner/GetCertificate/GetCert.yml | 1 + .../mispPartner/UploadCert/UploadCert.yml | 4 +- .../policy/GetPolicy/getPolicyResult.hbs | 19 +----- .../partner/policy/Search/SearchPolicy.yml | 40 +++--------- 20 files changed, 54 insertions(+), 192 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index ee73a5bb4a0..2ee8e7c5de0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -453,6 +453,8 @@ public static Map> doJsonOutputValidation(Stri public static Map> doJsonOutputValidation(String actualOutputJson, String expOutputJson, boolean checkErrorsOnlyInResponse, String context, boolean responseHasErrors) throws AdminTestException { + if (doesResponseHasErrorCode(actualOutputJson, 500)) + throw new AdminTestException("Internal Server Error. Hence marking the test case as failed"); JsonPrecondtion jsonPrecondtion = new JsonPrecondtion(); Map actual = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(actualOutputJson); Map exp = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(expOutputJson); @@ -462,7 +464,6 @@ public static Map> doJsonOutputValidation(Stri public static Map> doJsonOutputValidation(Map actualOutput, Map expOutput, boolean checkErrorsOnlyInResponse, String context, boolean responseHasErrors) throws AdminTestException { - try { return compareActuExpValue(actualOutput, expOutput, context); }catch (SkipException e) { @@ -489,4 +490,13 @@ public static boolean doesResponseHasErrors(String responseString) { return breturn; } + public static boolean doesResponseHasErrorCode(String responseString, int errorCode) { + JSONObject responseJson = new JSONObject(responseString); + if (responseJson.has("status")) { + return responseJson.getInt("status") == errorCode; + } + + return false; + } + } diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml index 48c8a96d620..b6b1bab98f1 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml @@ -15,13 +15,9 @@ DeviceDetailsFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "id", "fieldValue": "$IGNORE$", "fieldCode": "device-id-123" - } - ] }' partner_DeviceDetailsFilter_all_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/filtervalues @@ -39,13 +35,9 @@ DeviceDetailsFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "id", "fieldValue": "$IGNORE$", "fieldCode": "device-id-123" - } - ] }' partner_DeviceDetailsFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/devicedetail/filtervalues diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml index 7d59827b89c..f46affa4f53 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml @@ -15,13 +15,9 @@ DeviceSubTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "code", "fieldValue": "Single", "fieldCode": "Single" - } - ] }' partner_DeviceSubTypeFilter_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/deviceSubType/filtervalues @@ -39,13 +35,9 @@ DeviceSubTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "code", "fieldValue": "Single", "fieldCode": "Single" - } - ] }' partner_DeviceSubTypeFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/devicedetail/deviceSubType/filtervalues diff --git a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml index 686e072c570..ca15bea6662 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml @@ -14,11 +14,7 @@ ServiceToFilterSBI: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldValue": "Tech-123" - } - ] }' partner_ServiceToFilterSBI_All_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/filtervalues @@ -35,11 +31,7 @@ ServiceToFilterSBI: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldValue": "Tech-123" - } - ] }' partner_ServiceToFilterSBI_InValid_Empty_type: endPoint: /v1/partnermanager/securebiometricinterface/filtervalues diff --git a/automationtests/src/main/resources/partner/FtpPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/FtpPartner/UploadCert/UploadCert.yml index ac6529f0b27..40b178f40d3 100644 --- a/automationtests/src/main/resources/partner/FtpPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/FtpPartner/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ UploadPartnerCert: Partner_UploadCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/FtpPartner/UploadCert/uploadCert outputTemplate: partner/FtpPartner/UploadCert/uploadCertResult @@ -9,5 +10,4 @@ UploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/GetAllPolicyGroup/GetAllPolicyGroup.yml b/automationtests/src/main/resources/partner/GetAllPolicyGroup/GetAllPolicyGroup.yml index 4bec923360a..cd2180f8cde 100644 --- a/automationtests/src/main/resources/partner/GetAllPolicyGroup/GetAllPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/GetAllPolicyGroup/GetAllPolicyGroup.yml @@ -2,6 +2,7 @@ GetAllPolicyGroup: partner_GetAllPolicyGroup_allValid_smoke: endPoint: /v1/policymanager/policies/group/all role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetAllPolicyGroup/getAllPolicyGroup outputTemplate: partner/GetAllPolicyGroup/getAllPolicyGroupResult @@ -9,18 +10,4 @@ GetAllPolicyGroup: "requesttime": "$TIMESTAMP$" }' output: '{ - "policyGroup": { - "id": "$IGNORE$", - "crBy": "$IGNORE$", - "crDtimes": "$IGNORE$", - "delDtimes": "$IGNORE$", - "desc": "$IGNORE$", - "isActive": "$IGNORE$", - "isDeleted": "$IGNORE$", - "name": "$IGNORE$", - "updBy": "$IGNORE$", - "updDtimes": "$IGNORE$", - "userId": "$IGNORE$" - }, - "policies": "$IGNORE$" } ' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs b/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs index 4827f3ab021..80a333645ca 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/getPartnersPolicyResult.hbs @@ -26,30 +26,7 @@ "up_by": "$IGNORE$", "upd_dtimes": "$IGNORE$", - "policies": { - "shareableAttributes": [ - {{#each policies}} - { - "encrypted": $IGNORE$, - "attributeName": "$IGNORE$", - "source": [ - { - "attribute": "$IGNORE$" - } - ] - } - {{#unless @last}},{{/unless}} - {{/each}} - ], - "dataSharePolicies": { - "typeOfShare": "$IGNORE$", - "transactionsAllowed": "$IGNORE$", - "shareDomain": "$IGNORE$", - "encryptionType": "$IGNORE$", - "source": "$IGNORE$", - "validForInMinutes": "$IGNORE$" - } - } + "policies": "$IGNORE$" }, "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails.yml index 8a68b14cfb1..9332e78d80c 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails.yml @@ -2,6 +2,7 @@ createSearchDeviceDetails: Partner_SearchDeviceDetails_sort_type_desc_equals_Smoke_sid: endPoint: /v1/partnermanager/devicedetail/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails outputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult @@ -26,11 +27,11 @@ createSearchDeviceDetails: "version": "v1" }' output: '{ - "errors": [] }' Partner_SearchDeviceDetails_AllValid_Smoke: endPoint: /v1/partnermanager/devicedetail/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails outputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult @@ -42,11 +43,11 @@ createSearchDeviceDetails: "version": "v1" }' output: '{ - "errors": [] }' Partner_SearchDeviceDetails_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/devicedetail/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails outputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult @@ -65,11 +66,11 @@ createSearchDeviceDetails: "version": "v1" }' output: '{ - "errors": [] }' Partner_SearchDeviceDetails_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/devicedetail/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails outputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult @@ -87,11 +88,11 @@ createSearchDeviceDetails: "version": "v1" }' output: '{ - "errors": [] }' Partner_SearchDeviceDetails_Only_PaginationCriteria_Smoke: endPoint: /v1/partnermanager/devicedetail/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetails outputTemplate: partner/SearchAPIs/SearchDeviceDetails/createSearchDeviceDetailsResult @@ -103,7 +104,6 @@ createSearchDeviceDetails: "version": "v1" }' output: '{ - "errors": [] }' Partner_SearchDeviceDetails_with_invalid_columnName: endPoint: /v1/partnermanager/devicedetail/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml index f722652e607..1c2ce6237d1 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartner/createSearchPartner.yml @@ -2,6 +2,7 @@ createSearchPartner: Partner_SearchPartner_AllValid_Smoke: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -13,11 +14,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -40,6 +41,7 @@ createSearchPartner: Partner_SearchPartner_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -57,11 +59,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_Only_PaginationCriteria_Smoke: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -73,11 +75,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -102,11 +104,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_type_contains_Smoke_desc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -131,11 +133,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_type_equals_Smoke_desc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -160,11 +162,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_type_equals_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -189,11 +191,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_type_startswith_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -218,11 +220,11 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_type_startswith_Smoke_desc_sid: endPoint: /v1/partnermanager/partners/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartner outputTemplate: partner/SearchAPIs/SearchPartner/createSearchPartnerResult @@ -247,7 +249,6 @@ createSearchPartner: "version": "v1" }' output: '{ - "errors": "[]" }' Partner_SearchPartner_columnname_id_desc_sid: endPoint: /v1/partnermanager/partners/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml index 98be2cde580..01b15480355 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml @@ -2,6 +2,7 @@ createSearchPolicyGroup: Partner_SearchPolicyGroup_AllValid_Smoke: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -12,15 +13,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$" - } - ] }' Partner_SearchPolicyGroup_Only_FilterCriteria_Smoke: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -38,15 +35,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$" - } - ] }' Partner_SearchPolicyGroup_Only_SortCriteria_Smoke: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -63,15 +56,11 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$" - } - ] }' Partner_SearchPolicyGroup_Only_PaginationCriteria_Smoke: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -82,11 +71,6 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$" - } - ] }' Partner_SearchPolicyGroup_type_contains_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -114,15 +98,12 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "$IGNORE$" - } - ] }' Partner_SearchPolicyGroup_type_contains_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup outputTemplate: partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult @@ -146,12 +127,6 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$", - "isDeleted": "$IGNORE$" - } - ] }' Partner_SearchPolicyGroup_type_equals_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search @@ -179,12 +154,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "true", - "isDeleted":"false" - } - ] }' Partner_SearchPolicyGroup_type_equals_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -212,12 +182,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "true", - "isDeleted":"false" - } - ] }' Partner_SearchPolicyGroup_type_startswith_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -245,12 +210,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "true", - "isDeleted":"false" - } - ] }' Partner_SearchPolicyGroup_type_startswith_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search @@ -278,12 +238,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "true", - "isDeleted": "false" - } - ] }' Partner_SearchPolicyGroup_columnname_id_desc_smoke: endPoint: /v1/policymanager/policies/group/search @@ -311,11 +266,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "true" - } - ] }' Partner_SearchPolicyGroup_columnname_id_asc_smoke: endPoint: /v1/policymanager/policies/group/search @@ -343,11 +294,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "data": [ - { "isActive": "true" - } - ] }' Partner_SearchPolicyGroup_with_missing_columnName: diff --git a/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml index b405ee85bfc..f2b414f3ef5 100644 --- a/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/authPartner/GetCertificate/GetCert.yml @@ -2,6 +2,7 @@ GetPartnerCert: Partner_GetPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/{partnerId}/certificate role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/authPartner/GetCertificate/getCert outputTemplate: partner/authPartner/GetCertificate/getCertResult @@ -9,7 +10,6 @@ GetPartnerCert: "partnerId": "Tech-123" }' output: ' { - "errors": "$IGNORE$" }' Partner_GetPartnerCert_invalid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/certificate diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml index 97b1697cb96..e77eb6d4436 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml @@ -36,6 +36,7 @@ uploadPartnerCert: Partner_UploadPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/authPartner/UploadCert/uploadCert outputTemplate: partner/authPartner/UploadCert/uploadCertResult @@ -43,11 +44,11 @@ uploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' Partner_UploadPartnerCert_UploadAgain_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/authPartner/UploadCert/uploadCert outputTemplate: partner/authPartner/UploadCert/uploadCertResult @@ -55,5 +56,4 @@ uploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml index d4dc1fdd0bc..ce3062b9fb8 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/GetCertificate/GetCert.yml @@ -2,6 +2,7 @@ getPartnerCert: Partner_GetPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/{partnerId}/certificate role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/credentialPartner/GetCertificate/getCert outputTemplate: partner/credentialPartner/GetCertificate/getCertResult diff --git a/automationtests/src/main/resources/partner/credentialPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/credentialPartner/UploadCert/UploadCert.yml index f67a3e5fa4e..8b7e9ae9dc5 100644 --- a/automationtests/src/main/resources/partner/credentialPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/credentialPartner/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ uploadPartnerCert: Partner_UploadCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/credentialPartner/UploadCert/uploadCert outputTemplate: partner/credentialPartner/UploadCert/uploadCertResult @@ -9,5 +10,4 @@ uploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml index 047db235b30..613708be26e 100644 --- a/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/devicePartner/GetCertificate/GetCert.yml @@ -2,6 +2,7 @@ GetPartnerCert: Partner_GetPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/{partnerId}/certificate role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/devicePartner/GetCertificate/getCert outputTemplate: partner/devicePartner/GetCertificate/getCertResult diff --git a/automationtests/src/main/resources/partner/devicePartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/devicePartner/UploadCert/UploadCert.yml index 542273fe1cb..feed5f8a65a 100644 --- a/automationtests/src/main/resources/partner/devicePartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/devicePartner/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ uploadPartnerCert: Partner_UploadCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/devicePartner/UploadCert/uploadCert outputTemplate: partner/devicePartner/UploadCert/uploadCertResult @@ -9,5 +10,4 @@ uploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml b/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml index 242e5c858e0..3c7d8d39589 100644 --- a/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml +++ b/automationtests/src/main/resources/partner/mispPartner/GetCertificate/GetCert.yml @@ -2,6 +2,7 @@ getPartnerCert: Partner_GetPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/{partnerId}/certificate role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/mispPartner/GetCertificate/getCert outputTemplate: partner/mispPartner/GetCertificate/getCertResult diff --git a/automationtests/src/main/resources/partner/mispPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/mispPartner/UploadCert/UploadCert.yml index 11f7463eff5..40d056e6d44 100644 --- a/automationtests/src/main/resources/partner/mispPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/mispPartner/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ UploadPartnerCert: Partner_UploadCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/mispPartner/UploadCert/uploadCert outputTemplate: partner/mispPartner/UploadCert/uploadCertResult @@ -10,11 +11,11 @@ UploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' Partner_UploadCert_MispLicense_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/mispPartner/UploadCert/uploadCert2 outputTemplate: partner/mispPartner/UploadCert/uploadCertResult @@ -23,5 +24,4 @@ UploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs index f7812132c74..a79243df90e 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs @@ -26,23 +26,6 @@ "cr_dtimes": "$IGNORE$", "up_by": "$IGNORE$", "upd_dtimes": "$IGNORE$", - "policies": { - "allowedAuthTypes": [ - { - "authType": "$IGNORE$", - "authSubType": "$IGNORE$", - "mandatory": "$IGNORE$" - } - ], - "shareableAttributes": "$IGNORE$", - "allowedKYCAttributes": [ - { - "attributeName": "$IGNORE$", - } - ], - "dataSharePolicies": "$IGNORE$", - "authTokenType": "{{authTokenType}}" - } - }, + "policies": "$IGNORE$", "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml index 06f125c3fbe..a88b93db92f 100644 --- a/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/Search/SearchPolicy.yml @@ -2,6 +2,7 @@ createSearchPolicy: Partner_SearchPolicy_AllValid_Smoke: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -13,17 +14,11 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "$IGNORE$" - } - ] }' Partner_SearchPolicy_Valid_Smoke: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -35,17 +30,11 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "$IGNORE$" - } - ] }' Partner_SearchPolicy_Only_FilterCriteria_Smoke: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -64,11 +53,11 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": [] }' Partner_SearchPolicy_Only_SortaCriteria_Smoke: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -86,17 +75,11 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "$IGNORE$" - } - ] }' Partner_SearchPolicy_Only_PaginationCriteria_Smoke: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -108,13 +91,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "data": [ - { - "version": "$IGNORE$", - "policyType": "$IGNORE$", - "schema": "$IGNORE$" - } - ] }' Partner_SearchPolicy_type_contains_Smoke_asc: endPoint: /v1/policymanager/policies/search @@ -329,6 +305,8 @@ createSearchPolicy: Partner_SearchPolicy_with_invalid_value_contains: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -353,11 +331,11 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_invalid_value_equals: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -387,6 +365,7 @@ createSearchPolicy: Partner_SearchPolicy_with_invalid_value_startswith: endPoint: /v1/policymanager/policies/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/policy/Search/searchPolicy outputTemplate: partner/policy/Search/searchPolicyResult @@ -411,7 +390,6 @@ createSearchPolicy: "version": "v1" }' output: '{ - "errors": "$IGNORE$" }' Partner_SearchPolicy_with_invalid_columnName: endPoint: /v1/policymanager/policies/search From d1c91c6c50abd19a26827e3c0c05a60d5f866e0d Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 16 Aug 2023 11:48:30 +0530 Subject: [PATCH 029/204] MOSIP-28688 --- .../apirig/admin/fw/util/AdminTestUtil.java | 83 ++++++++++++++++++- .../apirig/testrunner/MosipTestRunner.java | 2 +- .../DemoAuthSimplePostForAutoGenId.java | 6 ++ .../resources/config/application.properties | 3 +- .../resources/config/valueMapping.properties | 3 + .../main/resources/ida/DemoAuth/DemoAuth.yml | 20 ++--- 6 files changed, 104 insertions(+), 13 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 7524924e42e..4f2b683c756 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4972,9 +4972,39 @@ public static String getLocationData() { String waitInterval = null; try { response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, - MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token, IDTOKENCOOKIENAME, idToken); + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); responseJson = new JSONObject(response.getBody().asString()); + + try { + JSONObject responseObject = new JSONObject(responseJson); + JSONArray data = responseObject.getJSONObject("response").getJSONArray("data"); + + + // Initialize variables for a, b, and c + String a = ""; + int b = -1; + String c = ""; + + for (int i = 0; i < data.length(); i++) { + JSONObject entry = data.getJSONObject(i); + String langCode = entry.getString("langCode"); + + if (BaseTestCase.languageList.get(0).equals(langCode)) { + a = entry.getString("hierarchyName"); + b = entry.getInt("hierarchyLevel"); + c = entry.optString("parentLocCode", ""); + break; + } + } + + System.out.println("a: " + a); + System.out.println("b: " + b); + System.out.println("c: " + c); + + } catch (Exception e) { + e.printStackTrace(); + } return waitInterval; @@ -4983,5 +5013,56 @@ public static String getLocationData() { return waitInterval; } } + + public static String inputTitleHandler(String jsonString) { + Response response = null; + JSONObject responseJson = null; + String url = ApplnURI + props.getProperty("fetchTitle"); + String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); + String firstWord = ""; + String value = ""; + String langcode = ""; + JSONObject jsonObject = new JSONObject(jsonString); + JSONArray nameArray = jsonObject.getJSONArray("name"); + if (nameArray.length() > 0) { + JSONObject nameObject = nameArray.getJSONObject(0); + value = nameObject.getString("value"); + firstWord = value.split("\\s+")[0]; //Miss-TitleFromServer + jsonString = jsonString.replace(firstWord, propsMap.getProperty(firstWord)); + firstWord = propsMap.getProperty(firstWord); //MIS + langcode = nameObject.getString("language"); + + } else { + System.out.println("No 'name' data found."); + } + + url = url + "/" + langcode; + try { + response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, + GlobalConstants.AUTHORIZATION, token); + + responseJson = new JSONObject(response.getBody().asString()); + } catch (Exception e) { + logger.error(e.getMessage()); + } + + try { + + JSONArray titleList = responseJson.getJSONObject("response").getJSONArray("titleList"); + for (int i = 0; i < titleList.length(); i++) { + JSONObject titleObject = titleList.getJSONObject(i); + if (titleObject.getString("code").equals(firstWord)) { + String titleName = titleObject.getString("titleName"); + jsonString = jsonString.replace(firstWord, titleName); + break; + } + } + } catch (Exception e) { + logger.error(e.getMessage()); + } + + return jsonString; + } + } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index c843a2a5ecc..0f54508834e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -78,7 +78,7 @@ public static void main(String[] arg) { KeycloakUserManager.removeUser(); KeycloakUserManager.createUsers(); - AdminTestUtil.getLocationData(); + //AdminTestUtil.getLocationData(); String partnerKeyURL = ""; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java index 425051e8110..cb2529be54d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java @@ -109,6 +109,12 @@ public void test(TestCaseDTO testCaseDTO) if (input.contains("$PRIMARYLANG$")) input = input.replace("$PRIMARYLANG$", BaseTestCase.languageList.get(0)); + + if (input.contains("name") & testCaseDTO.getTestCaseName().contains("titleFromAdmin")) { + input = AdminTestUtil.inputTitleHandler(input); + } + + if (input.contains("$NAMEPRIMARYLANG$")) { String name = ""; if (BaseTestCase.isTargetEnvLTS()) diff --git a/automationtests/src/main/resources/config/application.properties b/automationtests/src/main/resources/config/application.properties index 0b5915f6f8d..1ed6454312b 100644 --- a/automationtests/src/main/resources/config/application.properties +++ b/automationtests/src/main/resources/config/application.properties @@ -73,4 +73,5 @@ authAutoGeneratedIdPropFileName=/ida/autoGeneratedId.properties prerequisiteAutoGeneratedIdPropFileName=/prerequisite/autoGeneratedId.properties regProcAutoGeneratedIdPropFileName=/regProc/autoGeneratedId.properties mobileIdAutoGeneratedIdPropFileName=/mobileId/autoGeneratedId.properties -fetchLocationData=/v1/masterdata/locations/all \ No newline at end of file +fetchLocationData=/v1/masterdata/locations/all +fetchTitle=/v1/masterdata/title \ No newline at end of file diff --git a/automationtests/src/main/resources/config/valueMapping.properties b/automationtests/src/main/resources/config/valueMapping.properties index 7874da08aee..326e0c9b758 100644 --- a/automationtests/src/main/resources/config/valueMapping.properties +++ b/automationtests/src/main/resources/config/valueMapping.properties @@ -27,3 +27,6 @@ city=TEST_CITY zone=TEST_ZONE introducerName=TEST_INTRODUCERNAME bloodGroup=O +Miss-TitleFromServer=MIS +Mr-TitleFromServer=MIR +Mrs-TitleFromServer=MRS \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml index 20433041826..b4d64efd194 100644 --- a/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml +++ b/automationtests/src/main/resources/ida/DemoAuth/DemoAuth.yml @@ -389,7 +389,7 @@ DemoAuthNew: output: '{ "authStatus": "true" }' - auth_DemoAuth_same_Name2_Valid_uin_Smoke_Pos: + auth_DemoAuth_same_Name2_Valid_titleFromAdmin_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_demoauth_name_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident restMethod: post @@ -399,7 +399,7 @@ DemoAuthNew: "name": [ { "language": "eng", - "value": "Miss Lisa.GN" + "value": "Miss-TitleFromServer Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -408,7 +408,7 @@ DemoAuthNew: output: '{ "authStatus": "true" }' - auth_DemoAuth_same_Name3_Valid_uin_Smoke_Pos: + auth_DemoAuth_same_Name3_Valid_titleFromAdmin_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_demoauth_name_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident restMethod: post @@ -418,7 +418,7 @@ DemoAuthNew: "name": [ { "language": "eng", - "value": "Mr Lisa.GN" + "value": "Mr-TitleFromServer Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -446,7 +446,7 @@ DemoAuthNew: output: '{ "authStatus": "true" }' - auth_DemoAuth_same_Name5_Valid_uin_Smoke_Pos: + auth_DemoAuth_same_Name5_Valid_titleFromAdmin_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_demoauth_name_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident restMethod: post @@ -456,7 +456,7 @@ DemoAuthNew: "name": [ { "language": "eng", - "value": "Miss. Lisa.GN" + "value": "Miss-TitleFromServer. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -465,7 +465,7 @@ DemoAuthNew: output: '{ "authStatus": "true" }' - auth_DemoAuth_same_Name6_Valid_uin_Smoke_Pos: + auth_DemoAuth_same_Name6_Valid_titleFromAdmin_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_demoauth_name_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident restMethod: post @@ -475,7 +475,7 @@ DemoAuthNew: "name": [ { "language": "eng", - "value": "MISS. Lisa.GN" + "value": "Miss-TitleFromServer. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", @@ -484,7 +484,7 @@ DemoAuthNew: output: '{ "authStatus": "true" }' - auth_DemoAuth_same_Name7_Valid_uin_Smoke_Pos: + auth_DemoAuth_same_Name7_Valid_titleFromAdmin_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_demoauth_name_smoke_UIN$&partnerUrlSuffix=$PartnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident restMethod: post @@ -494,7 +494,7 @@ DemoAuthNew: "name": [ { "language": "eng", - "value": "Miss Lisa.GN" + "value": "Miss-TitleFromServer. Lisa.GN" } ], "timestamp": "$TIMESTAMP$", From 9d6da51dacf074d27e0d47deb22ed96c6d13e4a7 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 16 Aug 2023 13:18:50 +0530 Subject: [PATCH 030/204] MOSIP-28223 --- .../apirig/admin/fw/util/AdminTestUtil.java | 169 +++++++++--------- 1 file changed, 88 insertions(+), 81 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 5015311066a..d7770ce4432 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -2602,6 +2602,13 @@ public String uriKeyWordHandelerUri(String uri, String testCaseName) { return uri; } + + public String replaceKeywordWithValue(String jsonString, String keyword, String value) { + if (value != null && !value.isEmpty()) + return jsonString.replace(keyword, value); + else + throw new SkipException("Marking testcase as skipped as required fields are empty " + keyword); + } public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (jsonString == null) { @@ -2611,128 +2618,128 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (testCaseName.contains("ESignet_GenerateApiKey")) KeycloakUserManager.createKeyCloakUsers(genPartnerName, genPartnerEmail, "AUTH_PARTNER"); if (jsonString.contains("$THUMBPRINT$")) { - jsonString = jsonString.replace("$THUMBPRINT$", EncryptionDecrptionUtil.idaFirThumbPrint); + jsonString = replaceKeywordWithValue(jsonString, "$THUMBPRINT$", EncryptionDecrptionUtil.idaFirThumbPrint); } if (jsonString.contains("$ENCRYPTEDSESSIONKEY$")) { - jsonString = jsonString.replace("$ENCRYPTEDSESSIONKEY$", encryptedSessionKeyString); + jsonString = replaceKeywordWithValue(jsonString, "$ENCRYPTEDSESSIONKEY$", encryptedSessionKeyString); } if (jsonString.contains(GlobalConstants.MODULENAME)) { - jsonString = jsonString.replace(GlobalConstants.MODULENAME, BaseTestCase.certsForModule); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.MODULENAME, BaseTestCase.certsForModule); } if (jsonString.contains(GlobalConstants.CERTSDIR)) { - jsonString = jsonString.replace(GlobalConstants.CERTSDIR, ConfigManager.getauthCertsPath()); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.CERTSDIR, ConfigManager.getauthCertsPath()); } if (jsonString.contains("$BIOVALUE$")) { - jsonString = jsonString.replace("$BIOVALUE$", propsBio.getProperty("BioValue")); + jsonString = replaceKeywordWithValue(jsonString, "$BIOVALUE$", propsBio.getProperty("BioValue")); } if (jsonString.contains("$BIOVALUEWITHOUTFACE$")) { - jsonString = jsonString.replace("$BIOVALUEWITHOUTFACE$", propsBio.getProperty("BioValueWithoutFace")); + jsonString = replaceKeywordWithValue(jsonString, "$BIOVALUEWITHOUTFACE$", propsBio.getProperty("BioValueWithoutFace")); } if (jsonString.contains("$CLAIMSFROMCONFIG$")) - jsonString = jsonString.replace("$CLAIMSFROMCONFIG$", getValueFromConfigActuator()); + jsonString = replaceKeywordWithValue(jsonString, "$CLAIMSFROMCONFIG$", getValueFromConfigActuator()); if (jsonString.contains(GlobalConstants.TIMESTAMP)) - jsonString = jsonString.replace(GlobalConstants.TIMESTAMP, generateCurrentUTCTimeStamp()); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.TIMESTAMP, generateCurrentUTCTimeStamp()); if (jsonString.contains(GlobalConstants.TRANSACTION_ID)) - jsonString = jsonString.replace(GlobalConstants.TRANSACTION_ID, TRANSACTION_ID); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.TRANSACTION_ID, TRANSACTION_ID); if (jsonString.contains("$DATESTAMP$")) - jsonString = jsonString.replace("$DATESTAMP$", generateCurrentUTCDateStamp()); + jsonString = replaceKeywordWithValue(jsonString, "$DATESTAMP$", generateCurrentUTCDateStamp()); if (jsonString.contains("$TIMESTAMPL$")) - jsonString = jsonString.replace("$TIMESTAMPL$", generateCurrentLocalTimeStamp()); + jsonString = replaceKeywordWithValue(jsonString, "$TIMESTAMPL$", generateCurrentLocalTimeStamp()); if (jsonString.contains("$RID$")) - jsonString = jsonString.replace("$RID$", genRid); + jsonString = replaceKeywordWithValue(jsonString, "$RID$", genRid); if (jsonString.contains("$SCHEMAVERSION$")) - jsonString = jsonString.replace("$SCHEMAVERSION$", generateLatestSchemaVersion()); + jsonString = replaceKeywordWithValue(jsonString, "$SCHEMAVERSION$", generateLatestSchemaVersion()); if (jsonString.contains("$1STLANG$")) - jsonString = jsonString.replace("$1STLANG$", BaseTestCase.languageList.get(0)); + jsonString = replaceKeywordWithValue(jsonString, "$1STLANG$", BaseTestCase.languageList.get(0)); if (jsonString.contains("$2NDLANG$")) - jsonString = jsonString.replace("$2NDLANG$", BaseTestCase.languageList.get(1)); + jsonString = replaceKeywordWithValue(jsonString, "$2NDLANG$", BaseTestCase.languageList.get(1)); if (jsonString.contains("$3RDLANG$")) - jsonString = jsonString.replace("$3RDLANG$", BaseTestCase.languageList.get(2)); + jsonString = replaceKeywordWithValue(jsonString, "$3RDLANG$", BaseTestCase.languageList.get(2)); if (jsonString.contains(GlobalConstants.KEYCLOAK_USER_1)) - jsonString = jsonString.replace(GlobalConstants.KEYCLOAK_USER_1, propsKernel.getProperty("KEYCLOAKUSER1")); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.KEYCLOAK_USER_1, propsKernel.getProperty("KEYCLOAKUSER1")); if (jsonString.contains(GlobalConstants.KEYCLOAK_USER_2)) - jsonString = jsonString.replace(GlobalConstants.KEYCLOAK_USER_2, propsKernel.getProperty("KEYCLOAKUSER2")); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.KEYCLOAK_USER_2, propsKernel.getProperty("KEYCLOAKUSER2")); if (jsonString.contains("$RIDDEL$")) - jsonString = jsonString.replace("$RIDDEL$", genRidDel); + jsonString = replaceKeywordWithValue(jsonString, "$RIDDEL$", genRidDel); if (jsonString.contains("$ID:")) { String autoGenIdFileName = getAutoGenIdFileName(testCaseName); jsonString = replaceIdWithAutogeneratedId(jsonString, "$ID:", autoGenIdFileName); } if (jsonString.contains("$POLICYGROUPDESC$")) - jsonString = jsonString.replace("$POLICYGROUPDESC$", genPolicyGroupDesc); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYGROUPDESC$", genPolicyGroupDesc); if (jsonString.contains("$POLICYGROUPNAME$")) - jsonString = jsonString.replace("$POLICYGROUPNAME$", genPolicyGroupName); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYGROUPNAME$", genPolicyGroupName); if (jsonString.contains("$POLICYDESC$")) - jsonString = jsonString.replace("$POLICYDESC$", genPolicyDesc); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYDESC$", genPolicyDesc); if (jsonString.contains("$POLICYDESC1$")) - jsonString = jsonString.replace("$POLICYDESC1$", genPolicyDesc + "pol"); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYDESC1$", genPolicyDesc + "pol"); if (jsonString.contains("$POLICYNAME$")) - jsonString = jsonString.replace("$POLICYNAME$", genPolicyName); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYNAME$", genPolicyName); if (jsonString.contains("$POLICYNAMENONAUTH$")) - jsonString = jsonString.replace("$POLICYNAMENONAUTH$", genPolicyNameNonAuth); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYNAMENONAUTH$", genPolicyNameNonAuth); if (jsonString.contains("$POLICYNAME1$")) - jsonString = jsonString.replace("$POLICYNAME1$", genPolicyName + "pold"); + jsonString = replaceKeywordWithValue(jsonString, "$POLICYNAME1$", genPolicyName + "pold"); if (jsonString.contains(GlobalConstants.PARTNER_ID)) - jsonString = jsonString.replace(GlobalConstants.PARTNER_ID, genPartnerName); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.PARTNER_ID, genPartnerName); if (jsonString.contains("$PARTNERIDFORDSL$")) - jsonString = jsonString.replace("$PARTNERIDFORDSL$", genPartnerNameForDsl); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNERIDFORDSL$", genPartnerNameForDsl); if (jsonString.contains("$PARTNERID1$")) - jsonString = jsonString.replace("$PARTNERID1$", genPartnerName + "2n"); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNERID1$", genPartnerName + "2n"); if (jsonString.contains("$PARTNERIDNONAUTH$")) - jsonString = jsonString.replace("$PARTNERIDNONAUTH$", genPartnerNameNonAuth); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNERIDNONAUTH$", genPartnerNameNonAuth); if (jsonString.contains("$RANDOMPARTNEREMAIL$")) - jsonString = jsonString.replace("$RANDOMPARTNEREMAIL$", + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMPARTNEREMAIL$", "automation" + generateRandomNumberString(15) + GlobalConstants.MOSIP_NET); if (jsonString.contains("$PARTNEREMAIL1$")) - jsonString = jsonString.replace("$PARTNEREMAIL1$", "12d" + genPartnerEmail); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNEREMAIL1$", "12d" + genPartnerEmail); if (jsonString.contains("$PARTNEREMAIL$")) - jsonString = jsonString.replace("$PARTNEREMAIL$", genPartnerEmail); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNEREMAIL$", genPartnerEmail); if (jsonString.contains("$PARTNEREMAILFORDSL$")) - jsonString = jsonString.replace("$PARTNEREMAILFORDSL$", genPartnerEmailForDsl); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNEREMAILFORDSL$", genPartnerEmailForDsl); if (jsonString.contains("$PARTNEREMAILNONAUTH$")) - jsonString = jsonString.replace("$PARTNEREMAILNONAUTH$", genPartnerEmailNonAuth); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNEREMAILNONAUTH$", genPartnerEmailNonAuth); if (jsonString.contains("$MISPPOLICYGROUPDESC$")) - jsonString = jsonString.replace("$MISPPOLICYGROUPDESC$", genMispPolicyGroupDesc); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPOLICYGROUPDESC$", genMispPolicyGroupDesc); if (jsonString.contains("$MISPPOLICYGROUPNAME$")) - jsonString = jsonString.replace("$MISPPOLICYGROUPNAME$", genMispPolicyGroupName); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPOLICYGROUPNAME$", genMispPolicyGroupName); if (jsonString.contains("$MISPPOLICYDESC$")) - jsonString = jsonString.replace("$MISPPOLICYDESC$", genMispPolicyDesc); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPOLICYDESC$", genMispPolicyDesc); if (jsonString.contains("$MISPPOLICYNAME$")) - jsonString = jsonString.replace("$MISPPOLICYNAME$", genMispPolicyName); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPOLICYNAME$", genMispPolicyName); if (jsonString.contains("$RANDOMPOLICYNAME$")) - jsonString = jsonString.replace("$RANDOMPOLICYNAME$", generateRandomAlphaNumericString(15)); + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMPOLICYNAME$", generateRandomAlphaNumericString(15)); if (jsonString.contains("$RANDOMPARTNERID$")) - jsonString = jsonString.replace("$RANDOMPARTNERID$", generateRandomAlphaNumericString(15)); + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMPARTNERID$", generateRandomAlphaNumericString(15)); if (jsonString.contains("$MISPPARTNERID$")) - jsonString = jsonString.replace("$MISPPARTNERID$", genMispPartnerName); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPARTNERID$", genMispPartnerName); if (jsonString.contains("$MISPPARTNEREMAIL$")) - jsonString = jsonString.replace("$MISPPARTNEREMAIL$", genMispPartnerEmail); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPARTNEREMAIL$", genMispPartnerEmail); if (jsonString.contains("$CACERT$")) { JSONObject request = new JSONObject(jsonString); @@ -2751,7 +2758,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { caFtmCertValue = caFtmCertValue.replaceAll("\n", "\\\\n"); } - jsonString = jsonString.replace("$CACERT$", caFtmCertValue); + jsonString = replaceKeywordWithValue(jsonString, "$CACERT$", caFtmCertValue); } @@ -2771,7 +2778,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { caFtmCertValue = caFtmCertValue.replaceAll("\n", "\\\\n"); } - jsonString = jsonString.replace("$MISPCACERT$", caFtmCertValue); + jsonString = replaceKeywordWithValue(jsonString, "$MISPCACERT$", caFtmCertValue); } @@ -2793,7 +2800,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { interFtmCertValue = interFtmCertValue.replaceAll("\n", "\\\\n"); } - jsonString = jsonString.replace("$INTERCERT$", interFtmCertValue); + jsonString = replaceKeywordWithValue(jsonString, "$INTERCERT$", interFtmCertValue); } @@ -2813,7 +2820,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { interFtmCertValue = interFtmCertValue.replaceAll("\n", "\\\\n"); } - jsonString = jsonString.replace("$MISPINTERCERT$", interFtmCertValue); + jsonString = replaceKeywordWithValue(jsonString, "$MISPINTERCERT$", interFtmCertValue); } @@ -2833,7 +2840,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { partnerFtmCertValue = partnerFtmCertValue.replaceAll("\n", "\\\\r\\\\n"); } - jsonString = jsonString.replace("$PARTNERCERT$", partnerFtmCertValue); + jsonString = replaceKeywordWithValue(jsonString, "$PARTNERCERT$", partnerFtmCertValue); } @@ -2851,55 +2858,55 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { partnerFtmCertValue = partnerFtmCertValue.replaceAll("\n", "\\\\r\\\\n"); } - jsonString = jsonString.replace("$MISPPARTNERCERT$", partnerFtmCertValue); + jsonString = replaceKeywordWithValue(jsonString, "$MISPPARTNERCERT$", partnerFtmCertValue); } if (jsonString.contains("$PUBLICKEY$")) { - jsonString = jsonString.replace("$PUBLICKEY$", MosipTestRunner.generatePulicKey()); + jsonString = replaceKeywordWithValue(jsonString, "$PUBLICKEY$", MosipTestRunner.generatePulicKey()); publickey = JsonPrecondtion.getJsonValueFromJson(jsonString, "request.publicKey"); } if (jsonString.contains("$PUBLICKEYFORBINDING$")) { - jsonString = jsonString.replace("$PUBLICKEYFORBINDING$", MosipTestRunner.generatePublicKeyForMimoto()); + jsonString = replaceKeywordWithValue(jsonString, "$PUBLICKEYFORBINDING$", MosipTestRunner.generatePublicKeyForMimoto()); } if (jsonString.contains(GlobalConstants.PARTNER_ID)) { - jsonString = jsonString.replace(GlobalConstants.PARTNER_ID, getPartnerId()); + jsonString = replaceKeywordWithValue(jsonString, GlobalConstants.PARTNER_ID, getPartnerId()); } if (jsonString.contains("$APIKEY$")) { - jsonString = jsonString.replace("$APIKEY$", getAPIKey()); + jsonString = replaceKeywordWithValue(jsonString, "$APIKEY$", getAPIKey()); } if (jsonString.contains("$IDENTITYJSON$")) { - jsonString = jsonString.replace("$IDENTITYJSON$", generateIdentityJson(testCaseName)); + jsonString = replaceKeywordWithValue(jsonString, "$IDENTITYJSON$", generateIdentityJson(testCaseName)); } if (jsonString.contains("$RANDOMID$")) { - jsonString = jsonString.replace("$RANDOMID$2", RANDOM_ID_2); - jsonString = jsonString.replace("$RANDOMID$", RANDOM_ID); + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMID$2", RANDOM_ID_2); + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMID$", RANDOM_ID); } if (jsonString.contains("$RANDOMUUID$")) { - jsonString = jsonString.replace("$RANDOMUUID$", UUID.randomUUID().toString()); + jsonString = replaceKeywordWithValue(jsonString, "$RANDOMUUID$", UUID.randomUUID().toString()); } if (jsonString.contains("$BASEURI$")) { - jsonString = jsonString.replace("$BASEURI$", ApplnURI); + jsonString = replaceKeywordWithValue(jsonString, "$BASEURI$", ApplnURI); } if (jsonString.contains("$IDPUSER$")) { - jsonString = jsonString.replace("$IDPUSER$", propsKernel.getProperty("idpClientId")); + jsonString = replaceKeywordWithValue(jsonString, "$IDPUSER$", propsKernel.getProperty("idpClientId")); } if (jsonString.contains("$OIDCCLIENT$")) { - jsonString = jsonString.replace("$OIDCCLIENT$", + jsonString = replaceKeywordWithValue(jsonString, "$OIDCCLIENT$", getValueFromActuator(GlobalConstants.RESIDENT_DEFAULT_PROPERTIES, "mosip.iam.module.clientID")); } if (jsonString.contains("$IDPREDIRECTURI$")) { - jsonString = jsonString.replace("$IDPREDIRECTURI$", + jsonString = replaceKeywordWithValue(jsonString, "$IDPREDIRECTURI$", ApplnURI.replace(GlobalConstants.API_INTERNAL, "healthservices") + "/userprofile"); } if (jsonString.contains("$BASE64URI$")) { String redirectUri = ApplnURI.replace(GlobalConstants.API_INTERNAL, GlobalConstants.RESIDENT) + propsKernel.getProperty("currentUserURI"); - jsonString = jsonString.replace("$BASE64URI$", encodeBase64(redirectUri)); + jsonString = replaceKeywordWithValue(jsonString, "$BASE64URI$", encodeBase64(redirectUri)); } if (jsonString.contains("$JWKKEY$")) { - jsonString = jsonString.replace("$JWKKEY$", MosipTestRunner.generateJWKPublicKey()); + jsonString = replaceKeywordWithValue(jsonString, "$JWKKEY$", MosipTestRunner.generateJWKPublicKey()); } if (jsonString.contains("$BINDINGJWKKEY$")) { @@ -2910,7 +2917,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(bindingJWK1); } - jsonString = jsonString.replace("$BINDINGJWKKEY$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGJWKKEY$", jwkKey); } if (jsonString.contains("$BINDINGJWKKEYVID$")) { @@ -2921,7 +2928,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(bindingJWKVid); } - jsonString = jsonString.replace("$BINDINGJWKKEYVID$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGJWKKEYVID$", jwkKey); } if (jsonString.contains("$BINDINGCONSENTJWKKEY$")) { @@ -2932,7 +2939,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(bindingConsentJWK); } - jsonString = jsonString.replace("$BINDINGCONSENTJWKKEY$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTJWKKEY$", jwkKey); } if (jsonString.contains("$BINDINGCONSENTJWKKEYVID$")) { @@ -2943,7 +2950,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(bindingConsentJWKVid); } - jsonString = jsonString.replace("$BINDINGCONSENTJWKKEYVID$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTJWKKEYVID$", jwkKey); } if (jsonString.contains("$BINDINGCONSENTSAMECLAIMJWKKEY$")) { @@ -2954,7 +2961,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(bindingConsentSameClaimJWK); } - jsonString = jsonString.replace("$BINDINGCONSENTSAMECLAIMJWKKEY$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTSAMECLAIMJWKKEY$", jwkKey); } if (jsonString.contains("$BINDINGCONSENTSAMECLAIMVIDJWKKEY$")) { @@ -2965,7 +2972,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(bindingConsentVidSameClaimJWK); } - jsonString = jsonString.replace("$BINDINGCONSENTSAMECLAIMVIDJWKKEY$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$BINDINGCONSENTSAMECLAIMVIDJWKKEY$", jwkKey); } if (jsonString.contains("$OIDCJWKKEY$")) { @@ -2976,7 +2983,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(oidcJWK1); } - jsonString = jsonString.replace("$OIDCJWKKEY$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$OIDCJWKKEY$", jwkKey); } if (jsonString.contains("$OIDCJWKKEY2$")) { @@ -2987,7 +2994,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { } else { jwkKey = getJWKKey(oidcJWK2); } - jsonString = jsonString.replace("$OIDCJWKKEY2$", jwkKey); + jsonString = replaceKeywordWithValue(jsonString, "$OIDCJWKKEY2$", jwkKey); } if (jsonString.contains("$CLIENT_ASSERTION_JWK$")) { @@ -3004,7 +3011,7 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (request.has("client_id")) { clientId = request.get("client_id").toString(); } - jsonString = jsonString.replace("$CLIENT_ASSERTION_JWK$", signJWKKey(clientId, oidcJWKKey1)); + jsonString = replaceKeywordWithValue(jsonString, "$CLIENT_ASSERTION_JWK$", signJWKKey(clientId, oidcJWKKey1)); } if (jsonString.contains("$IDPCLIENTPAYLOAD$")) { String clientId = getValueFromActuator(GlobalConstants.RESIDENT_DEFAULT_PROPERTIES, @@ -3027,35 +3034,35 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { payloadBody.put("exp", epochValue + idTokenExpirySecs); payloadBody.put("iat", epochValue); - jsonString = jsonString.replace("$IDPCLIENTPAYLOAD$", encodeBase64(payloadBody.toString())); + jsonString = replaceKeywordWithValue(jsonString, "$IDPCLIENTPAYLOAD$", encodeBase64(payloadBody.toString())); } if (jsonString.contains("$WLATOKEN$")) { - jsonString = jsonString.replace("$WLATOKEN$", generateWLAToken(jsonString, bindingJWK1, bindingCertFile)); + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKEN$", generateWLAToken(jsonString, bindingJWK1, bindingCertFile)); } if (jsonString.contains("$WLATOKENVID$")) { - jsonString = jsonString.replace("$WLATOKENVID$", + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENVID$", generateWLAToken(jsonString, bindingJWKVid, bindingCertFileVid)); } if (jsonString.contains("$WLATOKENCONSENT$")) { - jsonString = jsonString.replace("$WLATOKENCONSENT$", + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENT$", generateWLAToken(jsonString, bindingConsentJWK, bindingCertConsentFile)); } if (jsonString.contains("$WLATOKENCONSENTVID$")) { - jsonString = jsonString.replace("$WLATOKENCONSENTVID$", + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTVID$", generateWLAToken(jsonString, bindingConsentJWKVid, bindingCertConsentVidFile)); } if (jsonString.contains("$WLATOKENCONSENTSAMECLAIM$")) { - jsonString = jsonString.replace("$WLATOKENCONSENTSAMECLAIM$", + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTSAMECLAIM$", generateWLAToken(jsonString, bindingConsentSameClaimJWK, bindingCertConsentSameClaimFile)); } if (jsonString.contains("$WLATOKENCONSENTVIDSAMECLAIM$")) { - jsonString = jsonString.replace("$WLATOKENCONSENTVIDSAMECLAIM$", + jsonString = replaceKeywordWithValue(jsonString, "$WLATOKENCONSENTVIDSAMECLAIM$", generateWLAToken(jsonString, bindingConsentVidSameClaimJWK, bindingCertConsentVidSameClaimFile)); } @@ -3244,9 +3251,9 @@ private String replaceIdWithAutogeneratedId(String jsonString, String idKey, Str time += " PM"; else time += " AM"; - jsonString = jsonString.replace(keyToReplace, time); + jsonString = replaceKeywordWithValue(jsonString, keyToReplace, time); } else - jsonString = jsonString.replace(keyToReplace, props.getProperty(keyForIdProperty)); + jsonString = replaceKeywordWithValue(jsonString, keyToReplace, props.getProperty(keyForIdProperty)); if (jsonString.contains("\u200B")) { jsonString = jsonString.replaceAll("\u200B", ""); } From da22dafe55d290bde8182c95d4f2784d69122aa4 Mon Sep 17 00:00:00 2001 From: Pankaj Godiyal Date: Wed, 16 Aug 2023 13:50:31 +0530 Subject: [PATCH 031/204] MOSIP-28926 --- .../apirig/kernel/util/KernelAuthentication.java | 6 ++++-- .../mosip/testrig/apirig/service/BaseTestCase.java | 12 ++++++------ 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java index 57a07691299..fd8e6aa79ad 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java @@ -30,8 +30,10 @@ public class KernelAuthentication extends BaseTestCase { public final Map props = clib.readProperty("Kernel"); private String admin_password = props.get("admin_password"); - private String admin_userName = props.get("admin_userName"); - + +// private String admin_userName = props.get("admin_userName"); + private String admin_userName = ConfigManager.getadminUserName(); + private String partner_password = props.get("partner_user_password"); private String partner_userName = props.get("partner_userName"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index a32137a9edd..b2478d1718b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -371,14 +371,14 @@ public static void mapUserToZone() { org.json.simple.JSONObject actualrequest = getRequestJson(zoneMappingRequest); JSONObject request = new JSONObject(); request.put("zoneCode", props.get("zoneCode_to_beMapped")); - request.put("userId", BaseTestCase.currentModule + "-" + propsKernel.get("admin_userName")); + request.put("userId", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); request.put("langCode", BaseTestCase.getLanguageList().get(0)); request.put(GlobalConstants.ISACTIVE, GlobalConstants.TRUE_STRING); actualrequest.put(GlobalConstants.REQUEST, request); logger.info(actualrequest); Response response = RestClient.postRequestWithCookie(url, actualrequest, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); - logger.info(propsKernel.get("admin_userName") + "Mapped to" + props.get("zoneCode_to_beMapped") + "Zone"); + logger.info(ConfigManager.getadminUserName() + "Mapped to" + props.get("zoneCode_to_beMapped") + "Zone"); logger.info(response); } @@ -409,7 +409,7 @@ public static void mapZone() { String url = ApplnURI + propsKernel.getProperty("zoneMappingActivateUrl"); HashMap map = new HashMap<>(); map.put(GlobalConstants.ISACTIVE, GlobalConstants.TRUE_STRING); - map.put("userId", BaseTestCase.currentModule + "-" + propsKernel.get("admin_userName")); + map.put("userId", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); Response response = RestClient.patchRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); logger.info(response); @@ -434,7 +434,7 @@ public static boolean zoneName() { HashMap map = new HashMap<>(); - map.put("userID", BaseTestCase.currentModule + "-" + propsKernel.get("admin_userName")); + map.put("userID", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); map.put("langCode", BaseTestCase.getLanguageList().get(0)); Response response = RestClient.getRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, @@ -456,7 +456,7 @@ public static void userCenterMapping() { HashMap requestMap = new HashMap<>(); - requestMap.put("id", BaseTestCase.currentModule + "-" + propsKernel.get("admin_userName")); + requestMap.put("id", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); requestMap.put("name", "automation"); requestMap.put("statusCode", "active"); // TODO remove hardcoding @@ -485,7 +485,7 @@ public static void userCenterMappingStatus() { HashMap map = new HashMap<>(); map.put(GlobalConstants.ISACTIVE, GlobalConstants.TRUE_STRING); - map.put("id", BaseTestCase.currentModule + "-" + propsKernel.get("admin_userName")); + map.put("id", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); Response response = RestClient.patchRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); From a2817a52ec7d4e9093bb4e13d7b0102a4f761cf9 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 16 Aug 2023 14:17:22 +0530 Subject: [PATCH 032/204] MOSIP-28925 --- .../mobileId/BindingOtp/BindingOtp.yml | 21 +- .../DownloadWithReqid/DownloadWithReqid.yml | 1 + .../mobileId/WalletBinding/WalletBinding.yml | 274 +++++++++++------- 3 files changed, 188 insertions(+), 108 deletions(-) diff --git a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml index 947b4bcf2c5..260b4f54748 100644 --- a/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml +++ b/automationtests/src/main/resources/mobileId/BindingOtp/BindingOtp.yml @@ -19,6 +19,7 @@ BindingOtp: MobileId_BindingOtp_Valid_vid_All_Smoke: endPoint: /residentmobileapp/binding-otp role: resident + checkErrorsOnlyInResponse: true restMethod: post validityCheckRequired: true inputTemplate: mobileId/BindingOtp/BindingOtp @@ -68,7 +69,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_identifier", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -131,7 +132,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -152,7 +153,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -173,7 +174,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -215,7 +216,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -425,7 +426,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_identifier", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -488,7 +489,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -509,7 +510,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -530,7 +531,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] @@ -572,7 +573,7 @@ BindingOtp: output: '{ "errors": [ { - "errorCode": "invalid_otp_channel", + "errorCode": "RESIDENT-APP-011", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml index 212ae795cdb..fb8202eec47 100644 --- a/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml +++ b/automationtests/src/main/resources/mobileId/CredentialIssuance/DownloadWithReqid/DownloadWithReqid.yml @@ -2,6 +2,7 @@ DownloadCredential: MobileId_CredentialsStatus_All_Valid_Smoke_euin: endPoint: /residentmobileapp/credentialshare/download role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: mobileId/CredentialIssuance/DownloadWithReqid/downloadwithreqid outputTemplate: mobileId/CredentialIssuance/DownloadWithReqid/downloadwithreqidResult diff --git a/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml b/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml index 331d5735b93..723a8f14ee3 100644 --- a/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml +++ b/automationtests/src/main/resources/mobileId/WalletBinding/WalletBinding.yml @@ -4,6 +4,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/WalletBinding/WalletBindingResult input: '{ @@ -18,7 +19,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -36,6 +37,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/WalletBinding/WalletBindingResult input: '{ @@ -50,7 +52,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -68,6 +70,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -82,7 +85,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -106,6 +109,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -120,7 +124,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -144,6 +148,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -158,7 +163,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -182,6 +187,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -196,7 +202,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -220,6 +226,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -234,7 +241,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -258,6 +265,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -272,7 +280,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -296,6 +304,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -310,7 +319,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -334,6 +343,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -348,7 +358,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -372,6 +382,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -386,7 +397,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -410,6 +421,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -424,7 +436,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -448,6 +460,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -462,7 +475,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -470,7 +483,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "key_binding_failed", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -486,6 +499,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -500,7 +514,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -524,6 +538,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -538,7 +553,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -562,6 +577,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -576,7 +592,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -600,6 +616,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -614,7 +631,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -622,7 +639,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "key_binding_failed", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -638,6 +655,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -652,7 +670,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -676,6 +694,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -690,7 +709,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -714,6 +733,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -728,7 +748,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -752,6 +772,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -766,7 +787,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -790,6 +811,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -804,7 +826,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -828,6 +850,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -842,7 +865,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -850,7 +873,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "IDA", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -866,6 +889,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -880,7 +904,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -904,6 +928,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -918,7 +943,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -942,6 +967,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -956,7 +982,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -980,6 +1006,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -994,7 +1021,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1002,7 +1029,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "IDA", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1018,6 +1045,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1032,7 +1060,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1040,7 +1068,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1056,6 +1084,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1070,7 +1099,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1094,6 +1123,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1108,7 +1138,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1132,6 +1162,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1146,7 +1177,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1154,7 +1185,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1170,6 +1201,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1184,7 +1216,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1192,7 +1224,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1208,6 +1240,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1222,7 +1255,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1230,7 +1263,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1246,6 +1279,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1260,7 +1294,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1284,6 +1318,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1298,7 +1333,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1322,6 +1357,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1336,7 +1372,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1344,7 +1380,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1360,6 +1396,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1374,7 +1411,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1382,7 +1419,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1398,6 +1435,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1412,7 +1450,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1436,6 +1474,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1450,7 +1489,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1474,6 +1513,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1488,7 +1528,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:AddIdentity_Binding_smoke_Pos_UIN$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1512,6 +1552,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1526,7 +1567,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1550,6 +1591,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1564,7 +1606,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1588,6 +1630,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1602,7 +1645,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1626,6 +1669,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1640,7 +1684,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1664,6 +1708,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1678,7 +1723,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1702,6 +1747,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1716,7 +1762,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1740,6 +1786,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1754,7 +1801,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1778,6 +1825,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1792,7 +1840,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1816,6 +1864,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1830,7 +1879,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1854,6 +1903,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1868,7 +1918,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1892,6 +1942,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1906,7 +1957,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1914,7 +1965,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "key_binding_failed", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -1930,6 +1981,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1944,7 +1996,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -1968,6 +2020,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -1982,7 +2035,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2006,6 +2059,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2020,7 +2074,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2044,6 +2098,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2058,7 +2113,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2066,7 +2121,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "key_binding_failed", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2082,6 +2137,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2096,7 +2152,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2120,6 +2176,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2134,7 +2191,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2158,6 +2215,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2172,7 +2230,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2196,6 +2254,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2210,7 +2269,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2234,6 +2293,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2248,7 +2308,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2272,6 +2332,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2286,7 +2347,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2294,7 +2355,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "IDA", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2310,6 +2371,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2324,7 +2386,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2348,6 +2410,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2362,7 +2425,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2386,6 +2449,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2400,7 +2464,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2424,6 +2488,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2438,7 +2503,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2446,7 +2511,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "IDA", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2462,6 +2527,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2476,7 +2542,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2484,7 +2550,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2500,6 +2566,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2514,7 +2581,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2538,6 +2605,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2552,7 +2620,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2576,6 +2644,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2590,7 +2659,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2598,7 +2667,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2614,6 +2683,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2628,7 +2698,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2636,7 +2706,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2652,6 +2722,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2666,7 +2737,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2674,7 +2745,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2690,6 +2761,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2704,7 +2776,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2728,6 +2800,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2742,7 +2815,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2766,6 +2839,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2780,7 +2854,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2788,7 +2862,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2804,6 +2878,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2818,7 +2893,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2826,7 +2901,7 @@ WalletBinding: output: '{ "errors": [ { - "errorCode": "invalid_challenge_format", + "errorCode": "invalid_auth_factor_type_or_challenge_format", "message": "$IGNORE$" } ], @@ -2842,6 +2917,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2856,7 +2932,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2880,6 +2956,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2894,7 +2971,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } @@ -2918,6 +2995,7 @@ WalletBinding: role: resident validityCheckRequired: true restMethod: post + checkErrorsOnlyInResponse: true inputTemplate: mobileId/WalletBinding/WalletBinding outputTemplate: mobileId/error input: '{ @@ -2932,7 +3010,7 @@ WalletBinding: "sendOtp":{ "requestTime": "$TIMESTAMP$", "individualId": "$ID:Generate_Perpetual_VID_Binding_Valid_Smoke_sid_vid$", - "otpChannels": [{channel: "email"},{channel: "phone"}], + "otpChannels": [{channel: "EMAIL"},{channel: "PHONE"}], "sendOtpReqTemplate": "mobileId/BindingOtp/BindingOtp", "sendOtpEndPoint": "/residentmobileapp/binding-otp" } From 64bd7973ce1c28d37159f6e1a1b66b90740309fd Mon Sep 17 00:00:00 2001 From: Pankaj Godiyal Date: Wed, 16 Aug 2023 17:02:03 +0530 Subject: [PATCH 033/204] MOSIP-28926 --- .../apirig/kernel/util/ConfigManager.java | 17 ++++++++++------- .../kernel/util/KernelAuthentication.java | 4 ++-- .../testrig/apirig/service/BaseTestCase.java | 12 ++++++------ 3 files changed, 18 insertions(+), 15 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index c0a868391c3..de5bf0aab56 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -63,7 +63,7 @@ public class ConfigManager { private static String ENABLE_DEBUG = "enableDebug"; private static String THREAD_COUNT = "threadCount"; private static String LANG_SELECT = "langselect"; - private static String ADMIN_USER_NAME = "admin_userName"; + private static String USEPRECONFIGOTP = "usePreConfiguredOtp"; private static String ESIGNET_BASE_URL = "eSignetbaseurl"; @@ -116,19 +116,21 @@ public class ConfigManager { private static String REPORT_EXPIRATION_IN_DAYS = "reportExpirationInDays"; private static String SCENARIOS_TO_BE_SKIPPED = "scenariosToSkip"; + private static String ADMIN_USER_NAME = "admin_userName"; private static String PARTNER_URL_SUFFIX = "partnerUrlSuffix"; private static String partnerUrlSuffix; private static String toSkippedList; + private static String userAdminName; private static String pms_client_secret; private static String partner_client_secret; private static String pms_client_id; private static String pms_app_id; private static String partner_client_id; - private static String admin_userName; + private static String resident_client_secret; @@ -379,10 +381,10 @@ public static void init() { : System.getenv(PARTNER_URL_SUFFIX); propsKernel.setProperty(PARTNER_URL_SUFFIX, partnerUrlSuffix); - admin_userName = System.getenv(ADMIN_USER_NAME) == null ? propsKernel.getProperty(ADMIN_USER_NAME) + userAdminName = System.getenv(ADMIN_USER_NAME) == null + ? propsKernel.getProperty(ADMIN_USER_NAME) : System.getenv(ADMIN_USER_NAME); - propsKernel.setProperty(ADMIN_USER_NAME, admin_userName); - + propsKernel.setProperty(ADMIN_USER_NAME, userAdminName); } public static boolean isInTobeSkippedList(String stringToFind) { @@ -397,8 +399,9 @@ public static boolean isInTobeSkippedList(String stringToFind) { return false; } - public static String getadminUserName() { - return admin_userName; + public static String getUserAdminName() { + return userAdminName; + } public static String getPartnerUrlSuffix() { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java index fd8e6aa79ad..e0f3e5ba8a3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KernelAuthentication.java @@ -32,7 +32,7 @@ public class KernelAuthentication extends BaseTestCase { private String admin_password = props.get("admin_password"); // private String admin_userName = props.get("admin_userName"); - private String admin_userName = ConfigManager.getadminUserName(); + private String admin_userName = ConfigManager.getUserAdminName(); private String partner_password = props.get("partner_user_password"); private String partner_userName = props.get("partner_userName"); @@ -217,7 +217,7 @@ public String getAuthForAdmin() { request.put(GlobalConstants.APPID, ConfigManager.getAdminAppId()); request.put(GlobalConstants.PASSWORD, admin_password); - request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule + "-" + admin_userName); + request.put(GlobalConstants.USER_NAME, BaseTestCase.currentModule + "-" + ConfigManager.getUserAdminName()); request.put(GlobalConstants.CLIENTID, ConfigManager.getAdminClientId()); request.put(GlobalConstants.CLIENTSECRET, ConfigManager.getAdminClientSecret()); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index b2478d1718b..7da0777a3da 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -371,14 +371,14 @@ public static void mapUserToZone() { org.json.simple.JSONObject actualrequest = getRequestJson(zoneMappingRequest); JSONObject request = new JSONObject(); request.put("zoneCode", props.get("zoneCode_to_beMapped")); - request.put("userId", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); + request.put("userId", BaseTestCase.currentModule + "-" + ConfigManager.getUserAdminName()); request.put("langCode", BaseTestCase.getLanguageList().get(0)); request.put(GlobalConstants.ISACTIVE, GlobalConstants.TRUE_STRING); actualrequest.put(GlobalConstants.REQUEST, request); logger.info(actualrequest); Response response = RestClient.postRequestWithCookie(url, actualrequest, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); - logger.info(ConfigManager.getadminUserName() + "Mapped to" + props.get("zoneCode_to_beMapped") + "Zone"); + logger.info(ConfigManager.getUserAdminName() + "Mapped to" + props.get("zoneCode_to_beMapped") + "Zone"); logger.info(response); } @@ -409,7 +409,7 @@ public static void mapZone() { String url = ApplnURI + propsKernel.getProperty("zoneMappingActivateUrl"); HashMap map = new HashMap<>(); map.put(GlobalConstants.ISACTIVE, GlobalConstants.TRUE_STRING); - map.put("userId", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); + map.put("userId", BaseTestCase.currentModule + "-" + ConfigManager.getUserAdminName()); Response response = RestClient.patchRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); logger.info(response); @@ -434,7 +434,7 @@ public static boolean zoneName() { HashMap map = new HashMap<>(); - map.put("userID", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); + map.put("userID", BaseTestCase.currentModule + "-" + ConfigManager.getUserAdminName()); map.put("langCode", BaseTestCase.getLanguageList().get(0)); Response response = RestClient.getRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, @@ -456,7 +456,7 @@ public static void userCenterMapping() { HashMap requestMap = new HashMap<>(); - requestMap.put("id", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); + requestMap.put("id", BaseTestCase.currentModule + "-" + ConfigManager.getUserAdminName()); requestMap.put("name", "automation"); requestMap.put("statusCode", "active"); // TODO remove hardcoding @@ -485,7 +485,7 @@ public static void userCenterMappingStatus() { HashMap map = new HashMap<>(); map.put(GlobalConstants.ISACTIVE, GlobalConstants.TRUE_STRING); - map.put("id", BaseTestCase.currentModule + "-" + ConfigManager.getadminUserName()); + map.put("id", BaseTestCase.currentModule + "-" + ConfigManager.getUserAdminName()); Response response = RestClient.patchRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); From 5200875ac5fba29fecbfab80beddfa67aa022be0 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Wed, 16 Aug 2023 17:04:59 +0530 Subject: [PATCH 034/204] resolved Prereg Comparison Issues --- .../testrig/apirig/admin/fw/util/AdminTestUtil.java | 6 +++--- .../mosip/testrig/apirig/testrunner/MosipTestRunner.java | 6 ++++-- .../main/resources/preReg/createPrereg/createPrereg.yml | 9 ++++++++- 3 files changed, 15 insertions(+), 6 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 4f2b683c756..813749eb336 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -4977,8 +4977,8 @@ public static String getLocationData() { responseJson = new JSONObject(response.getBody().asString()); try { - JSONObject responseObject = new JSONObject(responseJson); - JSONArray data = responseObject.getJSONObject("response").getJSONArray("data"); + JSONObject responseObject = responseJson.getJSONObject("response"); + JSONArray data = responseObject.getJSONArray("data"); // Initialize variables for a, b, and c @@ -5003,7 +5003,7 @@ public static String getLocationData() { System.out.println("c: " + c); } catch (Exception e) { - e.printStackTrace(); + logger.error(e.getMessage()); } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 0f54508834e..3acf50f1c82 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -78,7 +78,9 @@ public static void main(String[] arg) { KeycloakUserManager.removeUser(); KeycloakUserManager.createUsers(); - //AdminTestUtil.getLocationData(); + + List localLanguageList = new ArrayList<>(BaseTestCase.getLanguageList()); + AdminTestUtil.getLocationData(); String partnerKeyURL = ""; @@ -91,7 +93,7 @@ public static void main(String[] arg) { } - List localLanguageList = new ArrayList<>(BaseTestCase.getLanguageList()); + if (BaseTestCase.listOfModules.contains(GlobalConstants.MASTERDATA)) { diff --git a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml index ccfea7de3cd..71055494f0d 100644 --- a/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml +++ b/automationtests/src/main/resources/preReg/createPrereg/createPrereg.yml @@ -17,6 +17,7 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_All_Valid_Smoke_UpdateDocRefID_sid: @@ -37,6 +38,7 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_All_Valid_Smoke_BookByPRID_sid: @@ -56,7 +58,8 @@ CreatePrereg: "requesttime": "$TIMESTAMP$", "id": "mosip.pre-registration.demographic.create" }' - output: '{ + output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Valid_Smoke_sid: @@ -77,6 +80,7 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Smoke_alldel_sid: @@ -97,6 +101,7 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Smoke_CancellAppointment_sid: @@ -117,6 +122,7 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_Smoke_CancelApplicationsAppointment_sid: @@ -137,6 +143,7 @@ CreatePrereg: "id": "mosip.pre-registration.demographic.create" }' output: '{ + "statusCode": "Application_Incomplete", "langCode": "$1STLANG$" }' Prereg_CreatePrereg_in_Valid_id_sid: From 34d189cdc207b5dea9d060ebe1cccfcc003c2852 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 17 Aug 2023 12:08:32 +0530 Subject: [PATCH 035/204] MOSIP-28917 --- .../DeviceDetailsFilter.yml | 5 ++-- .../DeviceSubTypeFilter.yml | 8 ++--- .../DeviceTypeFilter/DeviceTypeFilter.yml | 8 ----- .../PartnerFilter/PartnerFilter.yml | 8 ----- .../PolicyGroupFilter/PolicyGroupFilter.yml | 8 ----- .../ServiceToFilterSBI/ServiceToFilterSBI.yml | 4 +-- .../UploadCert/UploadCert.yml | 2 +- .../GetApiKeyRequests/GetApiKeyRequests.yml | 2 +- .../GetBioExtractors/GetBioExtractors.yml | 2 +- .../partner/GetPartners/GetPartners.yml | 4 +-- .../GetPartnersPolicy/GetPartnersPolicy.yml | 1 + .../resources/partner/GetRoles/GetRoles.yml | 2 +- .../GetMispLicense/GetMispLicense.yml | 3 +- .../SearchMispLicense/SearchMispLicense.yml | 4 +-- .../SearchPartnerApiKey.yml | 30 ++++--------------- .../SearchPartnerApiRequestKey.yml | 12 ++------ .../searchPartnerApiRequestKeyResult.hbs | 6 ++-- .../createSearchPolicyGroup.yml | 8 ++--- .../createSearchPolicyGroupResult.hbs | 6 ++-- .../authPartner/UploadCert/UploadCert.yml | 2 +- .../UploadCertificate/UploadCertificate.yml | 2 +- .../create/CreateFTPChipDetail.yml | 4 +-- .../reject/RejectFtpChipDetail.yml | 2 +- .../reject/rejectFtpChipDetailResult.hbs | 4 +-- .../update/UpdateFtpChipDetail.yml | 2 +- .../policy/GetPolicy/getPolicyResult.hbs | 3 +- 26 files changed, 42 insertions(+), 100 deletions(-) diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml index b6b1bab98f1..216975dac80 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceDetailsFilter/DeviceDetailsFilter.yml @@ -2,6 +2,7 @@ DeviceDetailsFilter: partner_DeviceDetailsFilter_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/filtervalues role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilter outputTemplate: partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult @@ -15,13 +16,11 @@ DeviceDetailsFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "fieldID": "id", - "fieldValue": "$IGNORE$", - "fieldCode": "device-id-123" }' partner_DeviceDetailsFilter_all_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/filtervalues role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilter outputTemplate: partner/FilterAPIs/DeviceDetailsFilter/deviceDetailsFilterResult diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml index f46affa4f53..a6649a6640f 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceSubTypeFilter/DeviceSubTypeFilter.yml @@ -2,6 +2,7 @@ DeviceSubTypeFilter: partner_DeviceSubTypeFilter_All_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/deviceSubType/filtervalues role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilter outputTemplate: partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilterResult @@ -15,13 +16,11 @@ DeviceSubTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "fieldID": "code", - "fieldValue": "Single", - "fieldCode": "Single" }' partner_DeviceSubTypeFilter_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/deviceSubType/filtervalues role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilter outputTemplate: partner/FilterAPIs/DeviceSubTypeFilter/deviceSubTypeFilterResult @@ -35,9 +34,6 @@ DeviceSubTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "fieldID": "code", - "fieldValue": "Single", - "fieldCode": "Single" }' partner_DeviceSubTypeFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/devicedetail/deviceSubType/filtervalues diff --git a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml index 7a00ca5bf1e..3c3c3a3a4c0 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/DeviceTypeFilter/DeviceTypeFilter.yml @@ -15,13 +15,9 @@ DeviceTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "code", "fieldValue": "Finger", "fieldCode": "Finger" - } - ] }' partner_DeviceTypeFilter_Valid_Smoke: endPoint: /v1/partnermanager/devicedetail/deviceType/filtervalues @@ -39,13 +35,9 @@ DeviceTypeFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "code", "fieldValue": "Finger", "fieldCode": "Finger" - } - ] }' partner_DeviceTypeFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/devicedetail/deviceType/filtervalues diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml index cf8e208b23e..97ff0d5e5fd 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PartnerFilter/PartnerFilter.yml @@ -14,13 +14,9 @@ PartnerFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "id", "fieldValue": "mpartner-default-abis", "fieldCode": "mpartner-default-abis" - } - ] }' partner_PartnerFilter_all_Valid_Smoke: endPoint: /v1/partnermanager/partners/filtervalues @@ -37,13 +33,9 @@ PartnerFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "id", "fieldValue": "mpartner-default-abis", "fieldCode": "mpartner-default-abis" - } - ] }' partner_PartnerFilter_Invalid_EmptyFilterType: endPoint: /v1/partnermanager/partners/filtervalues diff --git a/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml b/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml index 542f517f28e..8f2c2b35b10 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/PolicyGroupFilter/PolicyGroupFilter.yml @@ -14,13 +14,9 @@ PolicyGroupFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "name", "fieldValue": "update_policy_group", "fieldCode": "update_policy_group" - } - ] }' partner_PolicyGroupFilter_all_Valid_Smoke: endPoint: /v1/policymanager/policies/group/filtervalues @@ -37,13 +33,9 @@ PolicyGroupFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [ - { "fieldID": "name", "fieldValue": "mpolicygroup-default-auth", "fieldCode": "mpolicygroup-default-auth" - } - ] }' partner_PolicyGroupFilter_using_desc_Valid_Smoke: endPoint: /v1/policymanager/policies/group/filtervalues diff --git a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml index ca15bea6662..af8ca00c271 100644 --- a/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml +++ b/automationtests/src/main/resources/partner/FilterAPIs/ServiceToFilterSBI/ServiceToFilterSBI.yml @@ -2,6 +2,7 @@ ServiceToFilterSBI: partner_ServiceToFilterSBI_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/filtervalues role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBI outputTemplate: partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBIResult @@ -14,11 +15,11 @@ ServiceToFilterSBI: "requesttime": "$TIMESTAMP$" }' output: '{ - "fieldValue": "Tech-123" }' partner_ServiceToFilterSBI_All_Valid_Smoke: endPoint: /v1/partnermanager/securebiometricinterface/filtervalues role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBI outputTemplate: partner/FilterAPIs/ServiceToFilterSBI/serviceToFilterSBIResult @@ -31,7 +32,6 @@ ServiceToFilterSBI: "requesttime": "$TIMESTAMP$" }' output: '{ - "fieldValue": "Tech-123" }' partner_ServiceToFilterSBI_InValid_Empty_type: endPoint: /v1/partnermanager/securebiometricinterface/filtervalues diff --git a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/UploadCert.yml index 40823261ebc..16fb0874b95 100644 --- a/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/GenerateApiKeyForApprovedPolicies/UploadCert/UploadCert.yml @@ -2,6 +2,7 @@ uploadPartnerCert: Partner_UploadPartnerCert_All_Valid_Smoke: endPoint: /v1/partnermanager/partners/certificate/upload role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/GenerateApiKeyForApprovedPolicies/UploadCert/uploadCert outputTemplate: partner/GenerateApiKeyForApprovedPolicies/UploadCert/uploadCertResult @@ -9,5 +10,4 @@ uploadPartnerCert: "requesttime": "$TIMESTAMP$" }' output: ' { - "errors": "$IGNORE$" }' diff --git a/automationtests/src/main/resources/partner/GetApiKeyRequests/GetApiKeyRequests.yml b/automationtests/src/main/resources/partner/GetApiKeyRequests/GetApiKeyRequests.yml index cd1fab6aeac..e654adc17c1 100644 --- a/automationtests/src/main/resources/partner/GetApiKeyRequests/GetApiKeyRequests.yml +++ b/automationtests/src/main/resources/partner/GetApiKeyRequests/GetApiKeyRequests.yml @@ -2,11 +2,11 @@ GetApiKeyRequests: Partner_GetApiKeyRequests_allValid_smoke: endPoint: /v1/partnermanager/partners/apikey role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetApiKeyRequests/getApiKeyRequests outputTemplate: partner/GetApiKeyRequests/getApiKeyRequestsResult input: '{ }' output: '{ - "errors": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/GetBioExtractors/GetBioExtractors.yml b/automationtests/src/main/resources/partner/GetBioExtractors/GetBioExtractors.yml index 21d79ad7f0c..60ef94004a2 100644 --- a/automationtests/src/main/resources/partner/GetBioExtractors/GetBioExtractors.yml +++ b/automationtests/src/main/resources/partner/GetBioExtractors/GetBioExtractors.yml @@ -2,6 +2,7 @@ GetBioExtractors: Partner_GetBioExtractors_allValid_smoke: endPoint: /v1/partnermanager/partners/{partnerId}/bioextractors/{policyId} role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetBioExtractors/getBioExtractors outputTemplate: partner/GetBioExtractors/getBioExtractorsResult @@ -10,7 +11,6 @@ GetBioExtractors: "policyId": "mpolicy-default-auth" }' output: '{ - "errors": "$IGNORE$" }' Partner_GetBioExtractors_InValid_partnerId: endPoint: /v1/partnermanager/partners/{partnerId}/bioextractors/{policyId} diff --git a/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml b/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml index fa8cda871e2..974259c3248 100644 --- a/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml +++ b/automationtests/src/main/resources/partner/GetPartners/GetPartners.yml @@ -2,24 +2,24 @@ GetPartners: Partner_GetPartners_allValid_smoke: endPoint: /v1/partnermanager/partners role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetPartners/getPartners outputTemplate: partner/GetPartners/getPartnersResult input: '{ }' output: '{ - "partnerType": "$IGNORE$" }' Partner_GetPartners_ByPartnerType_allValid_smoke: endPoint: /v1/partnermanager/partners?partnerType=Device_Provider role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetPartners/getPartners outputTemplate: partner/GetPartners/getPartnersResult input: '{ }' output: '{ - "partnerType": "Device_Provider" }' Partner_GetPartners_invalid_partnerType: endPoint: /v1/partnermanager/partners?partnerType=zsfvgefb diff --git a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml index eff2f13384f..b678bc93b54 100644 --- a/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml +++ b/automationtests/src/main/resources/partner/GetPartnersPolicy/GetPartnersPolicy.yml @@ -2,6 +2,7 @@ GetPartnersPolicy: partner_GetPartnersPolicy_allValid_smoke: endPoint: /v1/policymanager/policies/{policyId}/partner/{partnerId} role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetPartnersPolicy/getPartnersPolicy outputTemplate: partner/GetPartnersPolicy/getPartnersPolicyResult diff --git a/automationtests/src/main/resources/partner/GetRoles/GetRoles.yml b/automationtests/src/main/resources/partner/GetRoles/GetRoles.yml index 4aefe434821..69cf88ffc34 100644 --- a/automationtests/src/main/resources/partner/GetRoles/GetRoles.yml +++ b/automationtests/src/main/resources/partner/GetRoles/GetRoles.yml @@ -2,6 +2,7 @@ GetRoles: Partner_GetRoles_allValid_smoke: endPoint: /v1/partnermanager/roles role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/GetRoles/getRoles outputTemplate: partner/GetRoles/getRolesResult @@ -9,5 +10,4 @@ GetRoles: }' output: '{ - "errors": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/GetMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/GetMispLicense.yml index 98ea4303d12..8733f642052 100644 --- a/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/GetMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/GetMispLicense/GetMispLicense.yml @@ -2,13 +2,12 @@ GetMispLicense: Partner_GetMispLicense_allValid_smoke: endPoint: /v1/partnermanager/misps role: partner + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: partner/MispLicense/GetMispLicense/getMispLicense outputTemplate: partner/MispLicense/GetMispLicense/getMispLicenseResult input: '{ }' output: '{ - "isActive": true, - "errors": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml b/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml index d849db0c9b4..4d076d717c4 100644 --- a/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml +++ b/automationtests/src/main/resources/partner/MispLicense/SearchMispLicense/SearchMispLicense.yml @@ -2,6 +2,7 @@ SearchMispLicense: Partner_SearchMispLicense_Valid_Smoke: endPoint: /v1/partnermanager/misps/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/MispLicense/SearchMispLicense/searchMispLicense outputTemplate: partner/MispLicense/SearchMispLicense/searchMispLicenseResult @@ -17,11 +18,11 @@ SearchMispLicense: "requesttime": "$TIMESTAMP$" }' output: '{ - "errors": null }' Partner_SearchMispLicense_Valid_Filter_Name: endPoint: /v1/partnermanager/misps/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/MispLicense/SearchMispLicense/searchMispLicense outputTemplate: partner/MispLicense/SearchMispLicense/searchMispLicenseResult @@ -40,7 +41,6 @@ SearchMispLicense: "requesttime": "$TIMESTAMP$" }' output: '{ - "errors": null }' Partner_SearchMispLicense_Invalid_NegPageFetch: endPoint: /v1/partnermanager/misps/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml index 851e9f72afc..8d5d630587b 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiKey/SearchPartnerApiKey.yml @@ -2,6 +2,7 @@ SearchPartnerApiKey: Partner_SearchPartnerApiKey_AllValid_Smoke: endPoint: /v1/partnermanager/partners/apikey/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKey outputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult @@ -11,15 +12,11 @@ SearchPartnerApiKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "policyApiKey": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiKey_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKey outputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult @@ -36,15 +33,11 @@ SearchPartnerApiKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "policyApiKey": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiKey_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKey outputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult @@ -60,15 +53,11 @@ SearchPartnerApiKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "policyApiKey": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiKey_Only_Pagination_Criteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKey outputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult @@ -78,15 +67,11 @@ SearchPartnerApiKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "policyApiKey": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiKey_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/apikey/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKey outputTemplate: partner/SearchAPIs/SearchPartnerApiKey/searchPartnerApiKeyResult @@ -109,11 +94,6 @@ SearchPartnerApiKey: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "policyApiKey": "$IGNORE$" - } - ] }' Partner_SearchPartnerApiKey_type_contains_invalid_pagination: endPoint: /v1/partnermanager/partners/apikey/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml index fea2e1b44b5..341fe601577 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/SearchPartnerApiRequestKey.yml @@ -21,6 +21,7 @@ SearchPartnerApiRequestKey: Partner_SearchPartnerApiRequestKey_Only_FilterCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKey outputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult @@ -38,11 +39,6 @@ SearchPartnerApiRequestKey: "version": "v1" }' output: '{ - "data": [ - { - "apikeyRequestId": "mpartner_policy_auth_req" - } - ] }' Partner_SearchPartnerApiRequestKey_Only_SortCriteria_Smoke: endPoint: /v1/partnermanager/partners/apikey/request/search @@ -91,6 +87,7 @@ SearchPartnerApiRequestKey: Partner_SearchPartnerApiRequestKey_type_contains_Smoke_asc_sid: endPoint: /v1/partnermanager/partners/apikey/request/search role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKey outputTemplate: partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult @@ -109,11 +106,6 @@ SearchPartnerApiRequestKey: "version": "v1" }' output: '{ - "data": [ - { - "apikeyRequestId": "mpartner_policy_auth_req" - } - ] }' Partner_SearchPartnerApiRequestKey_type_contains_invalid_pagination: diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs index 4323335d136..d50472999a7 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPartnerApiRequestKey/searchPartnerApiRequestKeyResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml index 01b15480355..0b233af4d22 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml @@ -154,7 +154,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true", + "isActive": "true" }' Partner_SearchPolicyGroup_type_equals_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -182,7 +182,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true", + "isActive": "true" }' Partner_SearchPolicyGroup_type_startswith_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -210,7 +210,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true", + "isActive": "true" }' Partner_SearchPolicyGroup_type_startswith_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search @@ -238,7 +238,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true", + "isActive": "true" }' Partner_SearchPolicyGroup_columnname_id_desc_smoke: endPoint: /v1/policymanager/policies/group/search diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs index a232e7f324a..8f14c01df75 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs @@ -1,6 +1,6 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", @@ -12,7 +12,7 @@ "id": "$IGNORE$", "crBy": "$IGNORE$", "crDtimes": "$IGNORE$", - "delDtimes": null, + "delDtimes": "$IGNORE$", "descr": "$IGNORE$", "isActive": "{{isActive}}", "isDeleted": $IGNORE$, diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml b/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml index e77eb6d4436..35fd39d3056 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml +++ b/automationtests/src/main/resources/partner/authPartner/UploadCert/UploadCert.yml @@ -28,7 +28,7 @@ uploadPartnerCert: output: ' { "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "KER-KMS-013", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml index e4f73c1164c..d93c054f067 100644 --- a/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml +++ b/automationtests/src/main/resources/partner/authPartner/UploadCertificate/UploadCertificate.yml @@ -23,7 +23,7 @@ uploadCACert: output: ' { "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "KER-PCM-003", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml index d39c4486a96..56600b6ec66 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/create/CreateFTPChipDetail.yml @@ -2,6 +2,7 @@ CreateFTPChipDetail: Partner_CreateFTPChipDetail_All_Valid_Smoke_sid: endPoint: /v1/partnermanager/ftpchipdetail role: partner + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: partner/device/ftmChipDetails/create/createFTPChipDetail outputTemplate: partner/device/ftmChipDetails/create/createFTPChipDetailResult @@ -12,8 +13,7 @@ CreateFTPChipDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$" - }' +}' Partner_CreateFTPChipDetail_Missing_InputParameter_ftpProviderId: endPoint: /v1/partnermanager/ftpchipdetail diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml index 73d286d5273..e258eb61cc4 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/RejectFtpChipDetail.yml @@ -2,6 +2,7 @@ rejectFtpChipDetail: Partner_rejectFtpChipDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/ftpchipdetail role: partner + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: partner/device/ftmChipDetails/reject/rejectFtpChipDetail outputTemplate: partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult @@ -11,7 +12,6 @@ rejectFtpChipDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "Status updated successfully." }' Partner_rejectFtpChipDetail_Missing_InputParameter_ftpChipDetailId: diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs index 5b69b118b1e..1b686141c03 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/reject/rejectFtpChipDetailResult.hbs @@ -3,8 +3,6 @@ "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": "$IGNORE$", - "response": { - "id": "{{id}}" - }, + "response": "{{response}}", "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml index d6a985c4f01..a14c271a5af 100644 --- a/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml +++ b/automationtests/src/main/resources/partner/device/ftmChipDetails/update/UpdateFtpChipDetail.yml @@ -2,6 +2,7 @@ UpdateFtpChipDetail: Partner_UpdateFtpChipDetail_All_Valid_Smoke: endPoint: /v1/partnermanager/ftpchipdetail role: partner + checkErrorsOnlyInResponse: true restMethod: put inputTemplate: partner/device/ftmChipDetails/update/updateFtpChipDetail outputTemplate: partner/device/ftmChipDetails/update/updateFtpChipDetailResult @@ -12,7 +13,6 @@ UpdateFtpChipDetail: "requesttime": "$TIMESTAMP$" }' output: '{ - "id": "$IGNORE$" }' Partner_UpdateFtpChipDetail_Missing_InputParameter_ftpChipDetailId: diff --git a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs index a79243df90e..4e27766ce6c 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs +++ b/automationtests/src/main/resources/partner/policy/GetPolicy/getPolicyResult.hbs @@ -26,6 +26,7 @@ "cr_dtimes": "$IGNORE$", "up_by": "$IGNORE$", "upd_dtimes": "$IGNORE$", - "policies": "$IGNORE$", + "policies": "$IGNORE$" + }, "errors": "$IGNORE$" } \ No newline at end of file From a99d3490daa86a9e2fff95d1050b85a9595a84d4 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 17 Aug 2023 12:11:35 +0530 Subject: [PATCH 036/204] resolve conflicts --- .../src/main/resources/config/Kernel.properties | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index 6083afa61d4..ea8bcfa94c3 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -202,7 +202,7 @@ s3-account=automation s3-region=null reportExpirationInDays=3 # supported values yes or no -push-reports-to-s3=no +push-reports-to-s3=yes enableDebug=no # supported values are 1 to 8 threadCount=1 @@ -227,12 +227,12 @@ ida_db_schema=ida #----------------------------------AuthDemoService Host properties----------------------------------------------------------# #To run locally -authDemoServiceBaseURL=http://localhost -authDemoServicePort=8082 +#authDemoServiceBaseURL=http://localhost +#authDemoServicePort=8082 #To run in Docker -#authDemoServiceBaseURL=http://authdemo.apitestrig -#authDemoServicePort=80 +authDemoServiceBaseURL=http://authdemo.apitestrig +authDemoServicePort=80 #----------------------------------e-Signet properties----------------------------------------------------------# From f4162c38718e2946676e13dc1add99f4365ff3bf Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Thu, 17 Aug 2023 12:19:34 +0530 Subject: [PATCH 037/204] resolve conflicts --- automationtests/src/main/resources/config/Kernel.properties | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/resources/config/Kernel.properties b/automationtests/src/main/resources/config/Kernel.properties index ea8bcfa94c3..36cd118cbce 100644 --- a/automationtests/src/main/resources/config/Kernel.properties +++ b/automationtests/src/main/resources/config/Kernel.properties @@ -248,10 +248,10 @@ auditActuatorEndpoint=/v1/auditmanager/actuator/info validateBindingEndpoint=ida-binding #To run in Docker -#authCertsPath=/home/mosip/authcerts +authCertsPath=/home/mosip/authcerts #To run locally -authCertsPath= +#authCertsPath= preconfiguredOtp=111111 usePreConfiguredOtp=true From dc5c13ed9ee92a834612f6f70b97ba4882de93f4 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 10:17:04 +0530 Subject: [PATCH 038/204] MOSIP-28945 --- .../apirig/kernel/util/CommonLibrary.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index e17a96c24c1..b11d4645630 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -10,6 +10,7 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Paths; +import java.security.PublicKey; import java.text.SimpleDateFormat; import java.time.Clock; import java.time.LocalDateTime; @@ -31,6 +32,9 @@ import org.skyscreamer.jsonassert.JSONAssert; import org.testng.Assert; +import com.auth0.jwt.JWT; +import com.auth0.jwt.exceptions.JWTDecodeException; +import com.auth0.jwt.interfaces.DecodedJWT; import com.jayway.jsonpath.DocumentContext; import com.jayway.jsonpath.JsonPath; @@ -213,8 +217,31 @@ public boolean jsonComparator(String requestJson, String responseJson) throws Ad } public boolean isValidToken(String cookie) { + boolean bReturn = false; + if (cookie == null) + return bReturn; + try { + DecodedJWT decodedJWT = JWT.decode(cookie); + // Get the expiration time + long expirationTime = decodedJWT.getExpiresAt().getTime(); + // Check if the token is expired + if (expirationTime < System.currentTimeMillis()) { + System.out.println("The token is expired"); + } else { + bReturn = true; + System.out.println("The token is not expired"); + } + } catch (JWTDecodeException e) { + // The token is invalid + System.out.println("The token is invalid"); + } + return bReturn; + } + + public boolean isValidTokenOnline(String cookie) { logger.info("========= Revalidating the token ========="); + Response response = applicationLibrary.getWithoutParams("/v1/authmanager/authorize/admin/validateToken", cookie); JSONObject responseJson = null; From 5102cb8f288575b572c18717fac8efb1ca9e35a4 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 10:20:09 +0530 Subject: [PATCH 039/204] MOSIP-28917 --- .../src/main/resources/partner/policy/GetPolicy/GetPolicy.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/resources/partner/policy/GetPolicy/GetPolicy.yml b/automationtests/src/main/resources/partner/policy/GetPolicy/GetPolicy.yml index cf14db48dd8..53e8762cc61 100644 --- a/automationtests/src/main/resources/partner/policy/GetPolicy/GetPolicy.yml +++ b/automationtests/src/main/resources/partner/policy/GetPolicy/GetPolicy.yml @@ -10,10 +10,10 @@ getPolicy: }' output: ' { "policyGroupName": "mosip policy group", - "policyGroupDesc": "desc mosip policy group", + "policyGroupDesc": "desc mosip policy group updated", "policyGroupStatus": true, "policyName": "mosip policy", - "policyDesc": "desc mosip policy", + "policyDesc": "desc mosip policy updated", "authTokenType": "partner" }' Partner_GetPolicy_Invalid_InputParameter_policyId: From 9a118b8ad090d26ce539ba938e013928a6520faa Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 10:20:47 +0530 Subject: [PATCH 040/204] MOSIP-28922 --- .../main/resources/resident/AddIdentity/addIdentityResult.hbs | 4 ++-- .../resident/GenerateVID/createGenerateVIDNewResult.hbs | 4 ++-- .../resident/GenerateVID/createGenerateVIDResult.hbs | 4 ++-- .../main/resources/resident/SendOTP/createSendOTPResult.hbs | 4 ++-- .../resident/SendOTP/createSendOTPResultForEmail.hbs | 4 ++-- .../resident/SendOTP/createSendOTPResultForPhone.hbs | 4 ++-- .../SendOtpForExpiration/SendOtpForExpirationResult.hbs | 4 ++-- 7 files changed, 14 insertions(+), 14 deletions(-) diff --git a/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs index 720254c65ba..f972c850e57 100644 --- a/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/resident/AddIdentity/addIdentityResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.id.create", - "version": "v1", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "status": "{{status}}" diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs index 47dc940b6ea..f5b7072998d 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNewResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.resident.vid.generate", - "version": "1.0", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "vid": "{{vid}}", diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs index 97c855c020c..52cd68d71a0 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDResult.hbs @@ -1,9 +1,9 @@ { - "id": "mosip.resident.vid", + "id": "$IGNORE$", "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { - "vid": "{{vid}}", + "vid": "$IGNORE$", "message": "{{message}}" }, "errors": [] diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs index 555ca559a54..0668a51b54b 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", + "id": "$IGNORE$", + "version": "$IGNORE$", "responseTime": "$IGNORE$", "transactionID": "$IGNORE$", "metadata": "$IGNORE$", diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs index 7fc3005ca07..f02b83d1da2 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForEmail.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", + "id": "$IGNORE$", + "version": "$IGNORE$", "responseTime": "$IGNORE$", "transactionID": "$IGNORE$", "metadata": "$IGNORE$", diff --git a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs index 72659f98d1e..51c3caef0bb 100644 --- a/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs +++ b/automationtests/src/main/resources/resident/SendOTP/createSendOTPResultForPhone.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", + "id": "$IGNORE$", + "version": "$IGNORE$", "responseTime": "$IGNORE$", "transactionID": "$IGNORE$", "metadata": "$IGNORE$", diff --git a/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs b/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs index bd241fc2088..1532d0be00a 100644 --- a/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs +++ b/automationtests/src/main/resources/resident/SendOtpForExpiration/SendOtpForExpirationResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", + "id": "$IGNORE$", + "version": "$IGNORE$", "responseTime": "$IGNORE$", "transactionID": "$IGNORE$", "metadata": "$IGNORE$", From 3762fb5374383289f5597267dda08893583d3922 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 10:33:01 +0530 Subject: [PATCH 041/204] MOSIP-28945 --- .../mosip/testrig/apirig/kernel/util/CommonLibrary.java | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index b11d4645630..3e56a14c4a5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -222,18 +222,15 @@ public boolean isValidToken(String cookie) { return bReturn; try { DecodedJWT decodedJWT = JWT.decode(cookie); - // Get the expiration time long expirationTime = decodedJWT.getExpiresAt().getTime(); - // Check if the token is expired if (expirationTime < System.currentTimeMillis()) { - System.out.println("The token is expired"); + logger.info("The token is expired"); } else { bReturn = true; - System.out.println("The token is not expired"); + logger.info("The token is not expired"); } } catch (JWTDecodeException e) { - // The token is invalid - System.out.println("The token is invalid"); + logger.info("The token is invalid"); } return bReturn; } From 9b4dfd6fc58a247e446aea0db601cc599182ed6a Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 10:35:42 +0530 Subject: [PATCH 042/204] MOSIP-28945 --- .../java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index 3e56a14c4a5..a8df772281e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -230,7 +230,7 @@ public boolean isValidToken(String cookie) { logger.info("The token is not expired"); } } catch (JWTDecodeException e) { - logger.info("The token is invalid"); + logger.error("The token is invalid"); } return bReturn; } From bfbd544d85517b6b76abc7348dda8191680895fa Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 13:07:41 +0530 Subject: [PATCH 043/204] MOSIP-28948 --- .../apirig/admin/fw/util/AdminTestUtil.java | 43 ++++++++++++++----- 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 81dae1b4106..d166d5b5454 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -2,6 +2,7 @@ import static io.restassured.RestAssured.given; +import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; @@ -2502,20 +2503,40 @@ public Object[] getYmlTestData(String ymlPath) { @SuppressWarnings("unchecked") protected Map>> loadyaml(String path) { - Map>> scriptsMap = null; + Map>> scriptsMap = null; FileInputStream inputStream = null; - try { - Yaml yaml = new Yaml(); + BufferedInputStream bufferedInput = null; + int customBufferSize = 16384; // 16 KB + try { inputStream = new FileInputStream(new File(getResourcePath() + path).getAbsoluteFile()); - scriptsMap = (Map>>) yaml.load(inputStream); - } catch (Exception e) { - logger.error(e.getMessage()); - return null; - }finally { + bufferedInput = new BufferedInputStream(inputStream, customBufferSize); + Yaml yaml = new Yaml(); + scriptsMap = yaml.loadAs(bufferedInput, Map.class); + } catch (Exception e) { + logger.error("Error loading YAML: " + e.getMessage()); + } + finally { closeInputStream(inputStream); } - return scriptsMap; - } + return scriptsMap; + } + +// @SuppressWarnings("unchecked") +// protected Map>> loadyaml(String path) { +// Map>> scriptsMap = null; +// FileInputStream inputStream = null; +// try { +// Yaml yaml = new Yaml(); +// inputStream = new FileInputStream(new File(getResourcePath() + path).getAbsoluteFile()); +// scriptsMap = (Map>>) yaml.load(inputStream); +// } catch (Exception e) { +// logger.error(e.getMessage()); +// return null; +// }finally { +// closeInputStream(inputStream); +// } +// return scriptsMap; +// } public String getJsonFromTemplate(String input, String template) { return getJsonFromTemplate(input, template, true); @@ -2529,7 +2550,7 @@ public String getJsonFromTemplate(String input, String template, boolean readFil Gson gson = new Gson(); Type type = new TypeToken>() { }.getType(); - logger.info(input); +// logger.info(input); Map map = gson.fromJson(input, type); String templateJsonString; if (readFile) { From 7080c5eb7d7f77eb305968a83e4fcc70db4176dd Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 15:02:30 +0530 Subject: [PATCH 044/204] MOSIP-28956 --- .../apirig/admin/fw/util/TestJava.java | 50 +- .../authentication/fw/util/RestClient.java | 561 +++++++++++------- .../apirig/kernel/util/CommonLibrary.java | 240 +++++--- .../kernel/util/KeycloakUserManager.java | 34 +- .../apirig/testrunner/HealthChecker.java | 2 +- .../apirig/testrunner/MosipTestRunner.java | 27 +- 6 files changed, 584 insertions(+), 330 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java index 1e824613b2b..ec4adb45f73 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/TestJava.java @@ -19,20 +19,46 @@ public class TestJava { private static final Logger lOGGER = Logger.getLogger(TestJava.class); - private static final SecureRandom secureRandom = new SecureRandom(); + public static void main(String[] args) { + String spec = "{\r\n" + " \"post\": {\r\n" + " \"tags\": [\r\n" + + " \"resident-otp-controller\"\r\n" + " ],\r\n" + + " \"summary\": \"reqOtp\",\r\n" + " \"description\": \"reqOtp\",\r\n" + + " \"operationId\": \"reqOtp\",\r\n" + " \"requestBody\": {\r\n" + + " \"content\": {\r\n" + " \"application/json\": {\r\n" + + " \"schema\": {\r\n" + + " \"$ref\": \"#/components/schemas/OtpRequestDTO\"\r\n" + + " }\r\n" + " }\r\n" + " },\r\n" + + " \"required\": true\r\n" + " },\r\n" + + " \"responses\": {\r\n" + " \"201\": {\r\n" + + " \"description\": \"Created\"\r\n" + " },\r\n" + + " \"401\": {\r\n" + " \"description\": \"Unauthorized\"\r\n" + + " },\r\n" + " \"403\": {\r\n" + + " \"description\": \"Forbidden\"\r\n" + " },\r\n" + + " \"200\": {\r\n" + " \"description\": \"OK\",\r\n" + + " \"content\": {\r\n" + " \"*/*\": {\r\n" + + " \"schema\": {\r\n" + + " \"$ref\": \"#/components/schemas/OtpResponseDTO\"\r\n" + + " }\r\n" + " }\r\n" + + " }\r\n" + " },\r\n" + " \"404\": {\r\n" + + " \"description\": \"Not Found\"\r\n" + " }\r\n" + + " }\r\n" + " }\r\n" + " }"; - public static void main(String[] args) { - String string = "e2e_getPingHealth(packetcreator)"; - Pattern pattern = Pattern.compile("(.*?)\\((.*?),(.*)\\)"); - Matcher matcher = pattern.matcher(string); - if (matcher.matches()) { - System.out.println("The string contains a comma between parentheses"); - } else { - System.out.println("The string does not contain a comma between parentheses"); - } - } - + String response = "{\r\n" + " \"responseTime\": \"2023-08-16T00:19:16.779Z\",\r\n" + " \"errors\": [\r\n" + + " {\r\n" + " \"errorCode\": \"IDA-MLC-018\",\r\n" + + " \"errorMessage\": \"VID not available in database\"\r\n" + " }\r\n" + " ]\r\n" + "}"; + +// OpenApiValidator validator = new OpenApiValidator(); +// +// // Set the OpenAPI specification to the OpenApiValidator object +// validator.setOpenApiSpecification(openapiSpecification); +// +// // Set the JSON object to the OpenApiValidator object +// validator.setJson(jsonObject); + + // Call the validate() method of the OpenApiValidator object +// validator.validate(); + } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java index 7410dfb1235..eef9141a44c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/RestClient.java @@ -30,10 +30,11 @@ public class RestClient { private static final Logger RESTCLIENT_LOGGER = Logger.getLogger(RestClient.class); - private static RestAssuredConfig config = RestAssured.config() - .httpClient(HttpClientConfig.httpClientConfig().setParam("http.connection.timeout", 500000) - .setParam("http.socket.timeout", 500000).setParam("http.connection-manager.timeout", 500000)); +// private static RestAssuredConfig config = RestAssured.config() +// .httpClient(HttpClientConfig.httpClientConfig().setParam("http.connection.timeout", 500000) +// .setParam("http.socket.timeout", 500000).setParam("http.connection-manager.timeout", 500000)); + private static RestAssuredConfig config = RestAssured.config().httpClient(HttpClientConfig.httpClientConfig()); /** * REST ASSURED POST request method * @@ -45,19 +46,22 @@ public class RestClient { */ public static Response postRequestWithAuthHeader(String url, Object body, String contentHeader, String acceptHeader, String authHeaderName, String authHeaderValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then() .log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract() .response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); + return postResponse; } @@ -71,60 +75,66 @@ public static Response postRequestWithAuthHeader(String url, Object body, String * @return response */ public static Response postRequest(String url, Object body, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postWithFormPathParamAndFile(String url, Map formParams, Map pathParams, File file, String fileKeyName, String contentHeader, String cookie) { - RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); - RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); + RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .pathParams(pathParams).formParams(formParams).contentType(contentHeader).expect().when().post(url) .then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .pathParams(pathParams).formParams(formParams).contentType(contentHeader).expect().when().post(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } public static Response postWithParamsAndFile(String url, Map pathParams, File file, String fileKeyName, String contentHeader, String cookie) { - RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); - RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); + RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().extract() .response(); } - RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } @@ -133,35 +143,41 @@ public static Response postWithParamsAndFile(String url, Map pat Map tokens = new HashMap<>(); tokens.put(GlobalConstants.AUTHORIZATION, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); - RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); + RESTCLIENT_LOGGER.info("Name of the file is" + file.getName()); + postResponse = given().cookies(tokens).relaxedHTTPSValidation().multiPart(fileKeyName, file) .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookies(tokens).relaxedHTTPSValidation().multiPart(fileKeyName, file) .pathParams(pathParams).contentType(contentHeader).expect().when().post(url).then().extract() .response(); } - RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } public static Response postWithFormDataAndFile(String url, Map formParams, String filePath, String contentHeader, String cookie) { - RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) .multiPart("files", new File(filePath)).multiPart("tableName", formParams.get("tableName")) .multiPart(GlobalConstants.OPERATION, formParams.get(GlobalConstants.OPERATION)) .multiPart("category", formParams.get("category")).expect().when().post(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) .multiPart("files", new File(filePath)).multiPart("tableName", formParams.get("tableName")) @@ -170,14 +186,11 @@ public static Response postWithFormDataAndFile(String url, Map f .response(); } - RESTCLIENT_LOGGER.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - RESTCLIENT_LOGGER.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } public static Response postWithMultipartFormDataAndFile(String url, Map formParams, String contentHeader, String cookie) { - RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); RequestSpecification requestSpecification = given().cookie(builder.build()).relaxedHTTPSValidation() @@ -187,20 +200,21 @@ public static Response postWithMultipartFormDataAndFile(String url, Map formParams, File[] filePath, String contentHeader, String cookie) { - RESTCLIENT_LOGGER.info("REST:ASSURED:Sending post request with file to" + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); RequestSpecification requestSpecification = given().cookie(builder.build()).relaxedHTTPSValidation() @@ -210,10 +224,15 @@ public static Response postWithFormDataAndMultipleFile(String url, Map queryParams, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithQueryParamsAndBody(String url, Object body, Map queryParams, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response putRequestWithQueryParamAndBody(String url, Object body, Map queryParams, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request with query param " + url); Response puttResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request with query param " + url); + puttResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + puttResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + puttResponse.time()); } else { puttResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + puttResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + puttResponse.time()); return puttResponse; } @@ -315,17 +340,19 @@ public static Response putRequestWithQueryParamAndBody(String url, Object body, * @return response */ public static Response getRequest(String url, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("RESSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("RESSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().log().all().when().get(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().when().get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } @@ -339,18 +366,20 @@ public static Response getRequest(String url, String contentHeader, String accep * @return response */ public static Response postRequest(String url, File file, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().multiPart(file).contentType(contentHeader) .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().multiPart(file).contentType(contentHeader) .accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } @@ -364,19 +393,21 @@ public static Response postRequest(String url, File file, String contentHeader, * @return response */ public static Response postRequest(String url, String content, String contentHeader, MediaType acceptHeader) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(content).contentType(contentHeader) .accept(acceptHeader.toString()).log().all().when().post(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(content).contentType(contentHeader) .accept(acceptHeader.toString()).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } @@ -390,53 +421,59 @@ public static Response postRequest(String url, String content, String contentHea * @return response */ public static Response patchRequest(String url, String body, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).log().all().when().patch(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).when().patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static String getCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse.getCookie(cookieName); } public static Response postRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } @@ -445,186 +482,206 @@ public static Response postRequestWithCookie(String url, Object body, String con Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookies(tokens).accept(acceptHeader).log().all().when().post(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookies(tokens).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response deleteRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); Response deleteResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + deleteResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().delete(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); } else { deleteResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().delete(url).then().extract() .response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } public static Response postRequestWithoutCookie(String url, Object body, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithBearerToken(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all() .when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).when() .post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithHeder(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .header(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .header(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithMultipleHeaders(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() .post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithMultipleHeadersAndCookies(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).cookie("XSRF-TOKEN", "7d01b2a8-b89d-41ad-9361-d7f6294021d1") .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).cookie("XSRF-TOKEN", "7d01b2a8-b89d-41ad-9361-d7f6294021d1") .accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithMultipleHeadersWithoutCookie(String url, Object body, String contentHeader, String acceptHeader, Map headers) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response patchRequestWithMultipleHeaders(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response patchResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + patchResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() .patch(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + patchResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + patchResponse.time()); } else { patchResponse = given().config(config).relaxedHTTPSValidation().headers(headers).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + patchResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + patchResponse.time()); return patchResponse; } public static Response postRequestWithCookieAndHeader(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String authHeaderName, String authHeaderValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log() .all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when() .post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } @@ -634,74 +691,82 @@ public static Response postRequestWithCookieAndHeader(String url, Object body, S Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).cookies(tokens).accept(acceptHeader).log().all().when() .post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).cookies(tokens).accept(acceptHeader).when().post(url).then() .extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response patchRequestWithCookieAndHeader(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String authHeaderName, String authHeaderValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log() .all().when().patch(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().header(authHeaderName, authHeaderValue) .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when() .patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response getRequestWithCookie(String url, String contentHeader, String acceptHeader, String urls, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).log().all() .when().get(url + "?" + urls).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).when() .get(url + "?" + urls).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response patchRequestWithCookie(String url, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } @@ -710,54 +775,60 @@ public static Response patchRequestWithCookie(String url, String body, String co Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookies(tokens).accept(acceptHeader).log().all().when().patch(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookies(tokens).accept(acceptHeader).when().patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response patchRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response getRequestWithCookie(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).log().all() .when().get(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().cookie(cookieName, cookieValue).when() .get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } @@ -766,329 +837,363 @@ public static Response getRequestWithCookie(String url, String contentHeader, St Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().cookies(tokens).log().all().when().get(url) .then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().cookies(tokens).when().get(url).then() .extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response getRequestWithBearerToken(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().headers(cookieName, "Bearer " + cookieValue) .log().all().when().get(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().headers(cookieName, "Bearer " + cookieValue) .when().get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response getRequestWithCookieForKeyCloak(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) .relaxedHTTPSValidation().accept(acceptHeader).log().all().when().get(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) .relaxedHTTPSValidation().accept(acceptHeader).when().get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response getRequestWithCookieForUin(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation() .header(new Header("cookie", cookieName + cookieValue)).log().all().when().get(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation() .header(new Header("cookie", cookieName + cookieValue)).when().get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response postRequestWithCookie(String url, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response putRequestWithParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response patchRequestWithParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response putWithPathParamsBodyAndCookie(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() .put(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response putWithPathParamsBodyAndBearerToken(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).headers(cookieName, "Bearer " + cookieValue).accept(acceptHeader).log() .all().when().put(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).headers(cookieName, "Bearer " + cookieValue).accept(acceptHeader).when() .put(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postWithPathParamsBodyAndCookie(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() .post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postWithPathParamsBodyHeadersAndCookie(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, Map headers) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).pathParams(pathParams) .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log() .all().when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().headers(headers).pathParams(pathParams) .body(body).contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when() .post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postWithQueryParamsBodyAndCookie(String url, Map queryParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(queryParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() .post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().queryParams(queryParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postWithBodyAndCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response patchWithPathParamsBodyAndCookie(String url, Map pathParams, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when() .patch(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response postRequestWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().post(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response putRequestWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response putRequestWithCookie(String url, Object body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().put(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } @@ -1097,39 +1202,43 @@ public static Response putRequestWithCookie(String url, Object body, String cont Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookies(tokens).accept(acceptHeader).log().all().when().put(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader) .cookies(tokens).accept(acceptHeader).when().put(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } public static Response getRequestWithCookieAndPathParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) .cookie(cookieName, cookieValue).log().all().when().get(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) .cookie(cookieName, cookieValue).when().get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } @@ -1138,48 +1247,53 @@ public static Response getRequestWithCookieAndPathParm(String url, Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).log().all() .when().get(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).when() .get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response getRequestWithCookieAndPathParmForKeyCloak(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) .relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all().when().get(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config).contentType(contentHeader) .relaxedHTTPSValidation().body(body).accept(acceptHeader).when().get(url).then().extract() .response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static byte[] getPdf(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); byte[] pdf; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() .asByteArray(); @@ -1195,10 +1309,11 @@ public static byte[] getPdf(String url, Map body, String content Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); byte[] pdf; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + pdf = given().config(config).relaxedHTTPSValidation().pathParams(body).contentType("application/pdf") .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract().asByteArray(); } else { @@ -1211,10 +1326,11 @@ public static byte[] getPdf(String url, Map body, String content public static byte[] postWithBodyForPdf(String url, String body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); byte[] pdf; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept("*/*") .cookie(cookieName, cookieValue).log().all().when().get(url).then().extract().asByteArray(); } else { @@ -1230,10 +1346,11 @@ public static byte[] postWithBodyForPdf(String url, String body, String contentH Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); byte[] pdf; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + pdf = given().config(config).relaxedHTTPSValidation().body(body).contentType(contentHeader).accept("*/*") .cookies(tokens).log().all().when().get(url).then().extract().asByteArray(); } else { @@ -1246,10 +1363,11 @@ public static byte[] postWithBodyForPdf(String url, String body, String contentH public static byte[] getPdfWithQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); byte[] pdf; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") .accept("*/*").cookie(cookieName, cookieValue).log().all().when().get(url).then().extract() .asByteArray(); @@ -1266,10 +1384,11 @@ public static byte[] getPdfWithQueryParm(String url, Map body, S Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); byte[] pdf; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + pdf = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType("application/pdf") .accept("*/*").cookies(tokens).log().all().when().get(url).then().extract().asByteArray(); } else { @@ -1282,153 +1401,169 @@ public static byte[] getPdfWithQueryParm(String url, Map body, S public static Response getRequestWithCookieAndQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) .cookie(cookieName, cookieValue).log().all().when().get(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body) .cookie(cookieName, cookieValue).when().get(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response getRequestWithQueryParm(String url, Map body, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).log().all().when().get(url) .then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).when().get(url).then() .extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response patchRequestWithCookieAndQueryParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a PATCH request to " + url); + postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).log().all().when().patch(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().queryParams(body).contentType(contentHeader) .cookie(cookieName, cookieValue).accept(acceptHeader).when().patch(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public static Response deleteRequestWithCookieAndPathParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); Response deleteResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) .cookie(cookieName, cookieValue).log().all().when().delete(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); } else { deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) .cookie(cookieName, cookieValue).when().delete(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } public static Response deleteRequestWithCookieAndPathParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue, String idTokenName, String idTokenValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); Response deleteResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).log() .all().when().delete(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); } else { deleteResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).when() .delete(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } public static Response deleteRequest(String url, String contentHeader, String acceptHeader) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); Response deleteResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + deleteResponse = given().config(config).relaxedHTTPSValidation().log().all().when().delete(url).then().log() .all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); } else { deleteResponse = given().config(config).relaxedHTTPSValidation().when().delete(url).then().extract() .response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } public static Response deleteRequestWithCookieAndPathParmForKeyCloak(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); Response deleteResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a DELETE request to " + url); + deleteResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).log().all() .when().delete(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); } else { deleteResponse = given().headers(cookieName, "Bearer " + cookieValue).config(config) .contentType(contentHeader).relaxedHTTPSValidation().body(body).accept(acceptHeader).when() .delete(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + deleteResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + deleteResponse.time()); return deleteResponse; } public static Response postRequestWithCookieAndOnlyPathParm(String url, Map body, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) .cookie(cookieName, cookieValue).log().all().when().post(url).then().log().all().extract() .response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body) .cookie(cookieName, cookieValue).when().post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } @@ -1438,40 +1573,44 @@ public static Response postRequestWithCookieAndOnlyPathParm(String url, Map tokens = new HashMap<>(); tokens.put(cookieName, cookieValue); tokens.put(idTokenName, idTokenValue); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).log().all() .when().post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().config(config).relaxedHTTPSValidation().pathParams(body).cookies(tokens).when() .post(url).then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public static Response postRequestWithQueryParamBodyAndCookie(String url, Object body, Map queryParams, String contentHeader, String acceptHeader, String cookieName, String cookieValue) { - RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + RESTCLIENT_LOGGER.info("REST-ASSURED: Sending a POST request with query param " + url); + postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .cookie(cookieName, cookieValue).contentType(contentHeader).accept(acceptHeader).log().all().when() .post(url).then().log().all().extract().response(); + + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); + RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().config(config).relaxedHTTPSValidation().body(body).queryParams(queryParams) .cookie(cookieName, cookieValue).contentType(contentHeader).accept(acceptHeader).when().post(url) .then().extract().response(); } - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_2 + postResponse.asString()); - RESTCLIENT_LOGGER.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index a8df772281e..69af82ab56a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -291,157 +291,182 @@ public void responseLogger(Response response) { } public Response postWithoutJson(String url, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) .accept(acceptHeader).log().all().when().post(url).then().log().all().extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) .accept(acceptHeader).when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public Response postWithJson(String url, Object body, String contentHeader, String acceptHeader) { - logger.info("REST:ASSURED:Sending post request to" + url); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().relaxedHTTPSValidation().body(body).contentType(contentHeader).accept(acceptHeader) .log().all().when().post(url).then().log().all().extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString() + + GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().relaxedHTTPSValidation().body(body).contentType(contentHeader).accept(acceptHeader) .when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public Response postWithJson(String url, Object body, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - // log then response - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); return postResponse; } public Response postWithPathParams(String url, Object body, Map pathParams, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); + return postResponse; } public Response postWithOnlyPathParams(String url, Map pathParams, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); + return postResponse; } public Response postWithOnlyFile(String url, File file, String fileKeyName, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .expect().when().post(url).then().log().all().extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .expect().when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } public Response postWithFile(String url, Object body, File file, String fileKeyName, String contentHeader, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .body(body).contentType(contentHeader).expect().when().post(url).then().log().all().extract() .response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .body(body).contentType(contentHeader).expect().when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + postResponse.time()); + return postResponse; } public Response postWithFileFormParams(String url, Map formParams, File file, String fileKeyName, String contentHeader, String cookie) { - logger.info("REST:ASSURED:Sending post request to" + url); + logger.info("Name of the file is" + file.getName()); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST:ASSURED:Sending post request to" + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .formParams(formParams).contentType(contentHeader).expect().when().post(url).then().log().all() .extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().multiPart(fileKeyName, file) .formParams(formParams).contentType(contentHeader).expect().when().post(url).then().extract() .response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + postResponse.time()); return postResponse; } @@ -461,21 +486,25 @@ public Response postWithFilePathParamsFormParams(String url, Map public Response postWithQueryParams(String url, Map queryparams, Object body, String contentHeader, String acceptHeader, String cookie) { - logger.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response postResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info(GlobalConstants.REST_ASSURED_STRING_1 + url); + postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).queryParams(queryparams) .contentType(contentHeader).accept(acceptHeader).log().all().when().post(url).then().log().all() .extract().response(); + + logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); } else { postResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).queryParams(queryparams) .contentType(contentHeader).accept(acceptHeader).when().post(url).then().extract().response(); } - logger.info("REST-ASSURED: The response from request is: " + postResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + postResponse.time()); + return postResponse; } @@ -488,14 +517,16 @@ public Response postWithMultiHeaders(String endpoint, Object body, Map patharams, String cookie) { - logger.info("REST-ASSURED: Sending a GET request to " + url); - Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(patharams).log().all() .when().get(url); + + responseLogger(getResponse); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(patharams).when() .get(url); } - responseLogger(getResponse); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); + return getResponse; } public Response getWithQueryParam(String url, Map queryParams, String cookie) { - logger.info("REST-ASSURED: Sending a GET request to " + url); - Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log().all() .when().get(url); + + responseLogger(getResponse); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).when() .get(url); } - responseLogger(getResponse); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); + return getResponse; } public Response getWithQueryParamList(String url, Map> queryParams, String cookie) { - logger.info("REST-ASSURED: Sending a GET request to " + url); - Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log().all() .when().get(url); + + responseLogger(getResponse); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).when() .get(url); } - - responseLogger(getResponse); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public Response getWithPathQueryParam(String url, Map pathParams, Map queryParams, String cookie) { - logger.info("REST-ASSURED: Sending a GET request to " + url); - Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .queryParams(queryParams).log().all().when().get(url); + + responseLogger(getResponse); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .queryParams(queryParams).when().get(url); } - responseLogger(getResponse); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); + return getResponse; } public Response getWithPathParamQueryParamList(String url, Map pathParams, Map> queryParams, String cookie) { - logger.info("REST-ASSURED: Sending a GET request to " + url); - Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .queryParams(queryParams).log().all().when().get(url); + + responseLogger(getResponse); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .queryParams(queryParams).when().get(url); } - responseLogger(getResponse); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public Response putWithoutData(String url, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) .accept(acceptHeader).log().all().when().put(url).then().log().all().extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().contentType(contentHeader) .accept(acceptHeader).when().put(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } public Response putWithJson(String url, Object body, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).log().all().when().put(url).then().log().all().extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().body(body).contentType(contentHeader) .accept(acceptHeader).when().put(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } public Response putWithPathParams(String url, Map pathParams, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } public Response putWithQueryParams(String url, Map queryParams, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams) .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } public Response putWithPathParamsBody(String url, Map pathParams, Object body, String contentHeader, String acceptHeader, String cookie) { - logger.info("REST-ASSURED: Sending a PUT request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response putResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a PUT request to " + url); + putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).accept(acceptHeader).log().all().when().put(url).then().log().all() .extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); } else { putResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).body(body) .contentType(contentHeader).accept(acceptHeader).when().put(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + putResponse.asString()); - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + putResponse.time()); return putResponse; } public Response deleteWithPathParams(String url, Map pathParams, String cookie) { - logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a DELETE request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).log().all() .when().delete(url).then().log().all().extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams).when() .delete(url).then().extract().response(); } - - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; } public Response deleteWithQueryParams(String url, Map queryParams, String cookie) { - logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a DELETE request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).log().all() .when().delete(url).then().log().all().extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().queryParams(queryParams).when() .delete(url).then().extract().response(); } - - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; } public Response deleteWithPathQueryParams(String url, Map pathParams, Map queryParams, String cookie) { - logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a DELETE request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .queryParams(queryParams).log().all().when().delete(url).then().log().all().extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().pathParams(pathParams) .queryParams(queryParams).when().delete(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + getResponse.time()); + return getResponse; } public Response getConfigProperties(String url) { - logger.info("REST-ASSURED: Sending a GET request to " + url); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a GET request to " + url); + getResponse = given().relaxedHTTPSValidation().log().all().when().get(url).then().log().all().extract() .response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); } else { getResponse = given().relaxedHTTPSValidation().when().get(url).then().extract().response(); } - logger.info(GlobalConstants.REST_ASSURED_STRING_3 + getResponse.time()); return getResponse; } public Response deleteWithoutParams(String url, String cookie) { - logger.info("REST-ASSURED: Sending a DELETE request to " + url); Cookie.Builder builder = new Cookie.Builder(GlobalConstants.AUTHORIZATION, cookie); Response getResponse; if (ConfigManager.IsDebugEnabled()) { + logger.info("REST-ASSURED: Sending a DELETE request to " + url); + getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().log().all().when().delete(url).then() .log().all().extract().response(); + + logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); + logger.info("REST-ASSURED: the response time is: " + getResponse.time()); } else { getResponse = given().cookie(builder.build()).relaxedHTTPSValidation().when().delete(url).then().extract() .response(); } - - logger.info(GlobalConstants.REST_ASSURED_STRING_2 + getResponse.asString()); - logger.info("REST-ASSURED: the response time is: " + getResponse.time()); return getResponse; } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java index c6abb0db84d..f8f14a3c51a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/KeycloakUserManager.java @@ -34,21 +34,29 @@ public class KeycloakUserManager { private static final Logger logger = Logger.getLogger(KeycloakUserManager.class); public static Properties propsKernel = getproperty(MosipTestRunner.getResourcePath() + "/"+"config/Kernel.properties"); + public static Keycloak key = null; + + public static void closeKeycloakInstance() { + if (key != null) { + key.close(); + key = null; + } + } private static Keycloak getKeycloakInstance() { - Keycloak key=null; - try { - String automationClientId = BaseTestCase.isTargetEnvLTS() ? ConfigManager.getAutomationClientId() : ConfigManager.getPmsClientId(); - key=KeycloakBuilder.builder().serverUrl(ConfigManager.getIAMUrl()).realm(ConfigManager.getIAMRealmId()) - .grantType(OAuth2Constants.CLIENT_CREDENTIALS).clientId(automationClientId).clientSecret(ConfigManager.getAutomationClientSecret()) - .build(); - logger.info(ConfigManager.getIAMUrl()); - logger.info(key.toString() + key.realms()); - }catch(Exception e) - { - throw e; - - } + if (key != null) + return key; + try { + String automationClientId = BaseTestCase.isTargetEnvLTS() ? ConfigManager.getAutomationClientId() + : ConfigManager.getPmsClientId(); + key = KeycloakBuilder.builder().serverUrl(ConfigManager.getIAMUrl()) + .realm(ConfigManager.getIAMRealmId()).grantType(OAuth2Constants.CLIENT_CREDENTIALS) + .clientId(automationClientId).clientSecret(ConfigManager.getAutomationClientSecret()).build(); + logger.info(ConfigManager.getIAMUrl()); + logger.info(key.toString() + key.realms()); + } catch (Exception e) { + throw e; + } return key; } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java index 5699172581d..dbb1be379d6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java @@ -84,7 +84,7 @@ public void run() { signalTerminateExecution = true; } try { - Thread.sleep(60000); + Thread.sleep(120000); } catch (InterruptedException e) { logger.error(e.getMessage()); Thread.currentThread().interrupt(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 3acf50f1c82..f40c7184f81 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -14,6 +14,7 @@ import java.util.Map; import java.util.Properties; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.bouncycastle.openssl.jcajce.JcaPEMWriter; import org.testng.TestNG; @@ -65,6 +66,7 @@ public static void main(String[] arg) { ExtractResource.extractResourceFromJar(); } ConfigManager.init(); +// Logger.getRootLogger().setLevel(Level.ERROR); BaseTestCase.suiteSetup(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); @@ -76,7 +78,8 @@ public static void main(String[] arg) { trigger.start(); } KeycloakUserManager.removeUser(); - KeycloakUserManager.createUsers(); + KeycloakUserManager.createUsers(); + KeycloakUserManager.closeKeycloakInstance(); List localLanguageList = new ArrayList<>(BaseTestCase.getLanguageList()); @@ -211,14 +214,28 @@ public static String generatePulicKey() { } return publicKey; } + public static KeyPairGenerator keyPairGen = null; + + public static KeyPairGenerator getKeyPairGeneratorInstance() { + if (keyPairGen != null) + return keyPairGen; + try { + keyPairGen = KeyPairGenerator.getInstance("RSA"); + keyPairGen.initialize(2048); + + } catch (NoSuchAlgorithmException e) { + LOGGER.error(e.getMessage()); + } + + return keyPairGen; + } public static String generatePublicKeyForMimoto() { - KeyPairGenerator keyPairGen; + String vcString = ""; try { - keyPairGen = KeyPairGenerator.getInstance("RSA"); - keyPairGen.initialize(2048); - KeyPair keyPair = keyPairGen.generateKeyPair(); + KeyPairGenerator keyPairGenerator = getKeyPairGeneratorInstance(); + KeyPair keyPair = keyPairGenerator.generateKeyPair(); PublicKey publicKey = keyPair.getPublic(); StringWriter stringWriter = new StringWriter(); try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) { From 171f5ce4f1a8bd3aeda0f6fca514a85784ae39ee Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 17:53:18 +0530 Subject: [PATCH 045/204] MOSIP-28917 --- .../testrig/apirig/testrunner/MosipTestRunner.java | 12 ++++++++++++ .../SearchPolicyGroup/createSearchPolicyGroup.yml | 13 +++++++------ .../createSearchPolicyGroupResult.hbs | 2 +- .../makeAndModel/update/UpdateDeviceDetail.yml | 14 ++++++++------ .../update/updateDeviceDetailResult.hbs | 13 +++++-------- 5 files changed, 33 insertions(+), 21 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index f40c7184f81..f57f949ee15 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -16,6 +16,7 @@ import org.apache.log4j.Level; import org.apache.log4j.Logger; +import org.apache.log4j.PropertyConfigurator; import org.bouncycastle.openssl.jcajce.JcaPEMWriter; import org.testng.TestNG; @@ -66,6 +67,8 @@ public static void main(String[] arg) { ExtractResource.extractResourceFromJar(); } ConfigManager.init(); +// configureLog4j(); +// setLogLevelForAllClasses(Level.ERROR); // Logger.getRootLogger().setLevel(Level.ERROR); BaseTestCase.suiteSetup(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); @@ -135,6 +138,15 @@ public static void main(String[] arg) { System.exit(0); } + + private static void configureLog4j() { + // Configure log4j programmatically (you can also use a properties file) + PropertyConfigurator.configure(MosipTestRunner.getResourcePath() + "/" + "log4j.properties"); + } + private static void setLogLevelForAllClasses(Level level) { + Logger rootLogger = Logger.getRootLogger(); + rootLogger.setLevel(level); + } /** * The method to start mosip testng execution diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml index 0b233af4d22..88bb90cd308 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroup.yml @@ -127,6 +127,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ + "isActive": true }' Partner_SearchPolicyGroup_type_equals_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search @@ -154,7 +155,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true" + "isActive": true }' Partner_SearchPolicyGroup_type_equals_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -182,7 +183,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true" + "isActive": true }' Partner_SearchPolicyGroup_type_startswith_Smoke_asc_sid: endPoint: /v1/policymanager/policies/group/search @@ -210,7 +211,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true" + "isActive": true }' Partner_SearchPolicyGroup_type_startswith_Smoke_desc_sid: endPoint: /v1/policymanager/policies/group/search @@ -238,7 +239,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true" + "isActive": true }' Partner_SearchPolicyGroup_columnname_id_desc_smoke: endPoint: /v1/policymanager/policies/group/search @@ -266,7 +267,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true" + "isActive": true }' Partner_SearchPolicyGroup_columnname_id_asc_smoke: endPoint: /v1/policymanager/policies/group/search @@ -294,7 +295,7 @@ createSearchPolicyGroup: "version": "v1" }' output: '{ - "isActive": "true" + "isActive": true }' Partner_SearchPolicyGroup_with_missing_columnName: diff --git a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs index 8f14c01df75..d5b6c6593e4 100644 --- a/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs +++ b/automationtests/src/main/resources/partner/SearchAPIs/SearchPolicyGroup/createSearchPolicyGroupResult.hbs @@ -14,7 +14,7 @@ "crDtimes": "$IGNORE$", "delDtimes": "$IGNORE$", "descr": "$IGNORE$", - "isActive": "{{isActive}}", + "isActive": {{isActive}}, "isDeleted": $IGNORE$, "name": "$IGNORE$", "updBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml index a0f8f65f50e..1545d3847bc 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/UpdateDeviceDetail.yml @@ -16,10 +16,11 @@ createServiceToUpdateDeviceDetail: "model": "FRO90000", "partnerOrganizationName": "Techno", "requesttime": "$TIMESTAMP$" - }' +}' output: '{ - "id": "device-id-123" - }' + "id": "device-id-123" + }' + Partner_ServiceToUpdateDeviceDetail_afterReject_InValid: endPoint: /v1/partnermanager/devicedetail role: partner @@ -37,10 +38,11 @@ createServiceToUpdateDeviceDetail: "model": "FRO90000", "partnerOrganizationName": "Techno", "requesttime": "$TIMESTAMP$" - }' +}' output: '{ - "id": "device-id-124" - }' + "id": "device-id-124" + }' + Partner_ServiceToUpdateDeviceDetail_Missing_InputParameter_DeviceId: endPoint: /v1/partnermanager/devicedetail role: partner diff --git a/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs b/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs index 5b69b118b1e..34c024fa5fc 100644 --- a/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs +++ b/automationtests/src/main/resources/partner/device/makeAndModel/update/updateDeviceDetailResult.hbs @@ -1,10 +1,7 @@ { - "id": "$IGNORE$", - "version": "$IGNORE$", - "responsetime": "$IGNORE$", - "metadata": "$IGNORE$", - "response": { - "id": "{{id}}" - }, - "errors": "$IGNORE$" + "responsetime": "$IGNORE$", + "response": { + "id": "{{id}}" + }, + "errors": "$IGNORE$" } \ No newline at end of file From 96c16f51aa7f2818bdd485cf3df0eb1c2e6df780 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Fri, 18 Aug 2023 18:29:58 +0530 Subject: [PATCH 046/204] MOSIP-28924 --- .../ida/AddIdentity/addIdentityResult.hbs | 4 +- .../authInternalLockResult.hbs | 14 ++-- .../ida/AuthTransaction/AuthTransaction.yml | 6 -- .../ida/CreateVID/createVidResult.hbs | 6 +- .../main/resources/ida/EkycOtp/EkycOtp.yml | 24 +++++++ .../GenerateVID/createGenerateVIDResult.hbs | 2 +- .../ida/MultiFactorAuth/MultiFactorAuth.yml | 66 +++++++++++++++++++ .../main/resources/ida/OtpAuth/OtpAuth.yml | 24 +++++++ .../ida/RevokeVID/createRevokeVIDResult.hbs | 4 +- .../ida/SendOTP/createSendOTPResult.hbs | 4 +- 10 files changed, 132 insertions(+), 22 deletions(-) diff --git a/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs b/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs index 720254c65ba..f972c850e57 100644 --- a/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs +++ b/automationtests/src/main/resources/ida/AddIdentity/addIdentityResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.id.create", - "version": "v1", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "status": "{{status}}" diff --git a/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs b/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs index fa6c47257a7..a479056eefc 100644 --- a/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs +++ b/automationtests/src/main/resources/ida/AuthInternalLock/authInternalLockResult.hbs @@ -1,8 +1,10 @@ { - "id": null, - "version": null, - "responsetime": "{{responsetime}}", - "metadata": null, - "response": null, - "errors": [] + "id": "$IGNORE$", + "version": "$IGNORE$", + "responsetime": "$IGNORE$", + "metadata": "$IGNORE$", + "response": { + "message": "{{message}}" + }, + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml b/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml index 79a90bc18a1..bd252c58b6d 100644 --- a/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml +++ b/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml @@ -9,10 +9,7 @@ AuthTransaction: "individualId":"$ID:AddIdentity_ValidParam_smoke_Pos_UIN$" }' output: '{ -"authTransactions": [{ - "transactionID": "$TRANSACTIONID$", "referenceIdType": "UIN" - }] }' auth_AuthTransaction_allValid_smoke_VID: endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} @@ -24,8 +21,5 @@ AuthTransaction: "individualId":"$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$" }' output: '{ -"authTransactions": [{ - "transactionID": "$TRANSACTIONID$", "referenceIdType": "VID" - }] }' diff --git a/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs b/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs index 57d4400e238..1fc2e60613e 100644 --- a/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs +++ b/automationtests/src/main/resources/ida/CreateVID/createVidResult.hbs @@ -2,11 +2,11 @@ "id": "$IGNORE$", "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "vidStatus": "{{vidStatus}}", - "restoredVid": null, - "UIN": null, + "restoredVid": "$IGNORE$", + "UIN": "$IGNORE$", "VID": "$IGNORE$" }, "errors": [] diff --git a/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml b/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml index c52b6f05361..69914608b1e 100644 --- a/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml +++ b/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml @@ -2,6 +2,7 @@ EkycOtp: auth_EkycOtp_Auth_With_Valid_UIN_Smoke: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -23,6 +24,7 @@ EkycOtp: auth_EkycOtp_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -45,6 +47,7 @@ EkycOtp: auth_EkycOtp_Auth_With_Invalid_Past_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2022-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -66,6 +69,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_Past_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2022-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -88,6 +92,7 @@ EkycOtp: auth_EkycOtp_Auth_With_Invalid_Future_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2052-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: trues restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -109,6 +114,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_Future_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2052-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -131,6 +137,7 @@ EkycOtp: auth_EkycOtp_Auth_With_Invalid_Empty_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -152,6 +159,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_Empty_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -174,6 +182,7 @@ EkycOtp: auth_EkycOtp_With_revoke_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_to_revoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -201,6 +210,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_individualId_uin_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=@@###cndjdhe77473838&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -228,6 +238,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_individualId_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=@@###cndjdhe77473838&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -255,6 +266,7 @@ EkycOtp: auth_EkycOtp_With_Blank_individualId_uin_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -282,6 +294,7 @@ EkycOtp: auth_EkycOtp_With_Blank_individualId_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -309,6 +322,7 @@ EkycOtp: auth_EkycOtp_With_Missing_individualId_uin_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -336,6 +350,7 @@ EkycOtp: auth_EkycOtp_With_Missing_individualId_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&isKyc=true&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -363,6 +378,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_transactionId_uin_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=76544ddffgg@@@3444&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -384,6 +400,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_transactionId_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=76544ddffgg@@@3444&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -405,6 +422,7 @@ EkycOtp: auth_EkycOtp_With_Blank_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -426,6 +444,7 @@ EkycOtp: auth_EkycOtp_With_Blank_transactionId_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -447,6 +466,7 @@ EkycOtp: auth_EkycOtp_With_Invalid_individualIdType_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=ndjshswhw3277272&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -468,6 +488,7 @@ EkycOtp: auth_EkycOtp_With_Blank_individualIdType_VID_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult @@ -489,6 +510,7 @@ EkycOtp: auth_EkycOtp_With_Different_transaction_id_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=1234567891&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -510,6 +532,7 @@ EkycOtp: auth_EkycOtp_With_Different_transaction_id_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=1234567891&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error @@ -531,6 +554,7 @@ EkycOtp: auth_EkycOtp_With_invalid_uin_partner: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=1234567891&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/error diff --git a/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs b/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs index 97c855c020c..11ae4e88d64 100644 --- a/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs +++ b/automationtests/src/main/resources/ida/GenerateVID/createGenerateVIDResult.hbs @@ -1,5 +1,5 @@ { - "id": "mosip.resident.vid", + "id": "$IGNORE$", "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml index 9a205871b79..d12f6b6b7be 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml @@ -2,6 +2,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -40,6 +41,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_InValid_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -78,6 +80,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_Missing_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -116,6 +119,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_Valid_vid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -154,6 +158,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_revoked_vid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_to_revoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -198,6 +203,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_InValid_vid_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -236,6 +242,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_Face_With_blank_vid_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -274,6 +281,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RingFinger_With_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -312,6 +320,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RingFinger_With_missing_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -350,6 +359,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RingFinger_With_invalid_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -388,6 +398,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RingFinger_With_vid_InValid_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -425,6 +436,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RingFinger_With_vid_blank_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -463,6 +475,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RingFinger_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -501,6 +514,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -539,6 +553,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_uin_InValid_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -577,6 +592,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_uin_blank_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -615,6 +631,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftMiddleFingerr_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -653,6 +670,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIndexFingerr_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -691,6 +709,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIndexFingerr_With_Valid_vid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -729,6 +748,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftLittleFinger_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -767,6 +787,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftLittleFinger_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -805,6 +826,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightIndexFinger_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -843,6 +865,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightIndexFinger_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -881,6 +904,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightRingFinger_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -919,6 +943,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightRingFinger_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -957,6 +982,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightMiddleFinger_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -995,6 +1021,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightMiddleFinger_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1033,6 +1060,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightLittleFinger_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1071,6 +1099,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightLittleFinger_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1109,6 +1138,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftThumb_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1147,6 +1177,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftThumb_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1185,6 +1216,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightThumb_With_Valid_uin_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1223,6 +1255,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightThumb_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1261,6 +1294,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightIris_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1299,6 +1333,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_RightIris_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1337,6 +1372,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_uin_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1375,6 +1411,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With__VID_Valid_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1413,6 +1450,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_InValid_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1451,6 +1489,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_InValid_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=123@@###4567890&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1489,6 +1528,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_blank_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1527,6 +1567,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_uin_blank_transactionId_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1565,6 +1606,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_blank_individualIdType_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1603,6 +1645,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_individualIdType_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=12dd4@#$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/MultiFactorAuthResult @@ -1641,6 +1684,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1685,6 +1729,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1729,6 +1774,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_blank_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1773,6 +1819,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_blank_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1817,6 +1864,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_missing_bioSubType_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1861,6 +1909,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_missing_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: trues restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1905,6 +1954,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_BLANK_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$/idauthentication/v1/auth/$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1944,6 +1994,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_BLANK_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -1988,6 +2039,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_missing_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2032,6 +2084,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: trues restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2076,6 +2129,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_valid_bioType_and_invalid_digitalId_type: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2124,6 +2178,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_valid_bioType_and_invalid_digitalId_type: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2172,6 +2227,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_INvalid_bioValue: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2216,6 +2272,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_INvalid_bioValue: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2260,6 +2317,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_With_Face_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2304,6 +2362,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_With_Face_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2348,6 +2407,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_With_Finger_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: trues restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2392,6 +2452,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_With_Finger_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2436,6 +2497,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_Bio-Type_value_as_IR_instead_of_Iris: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: trues restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2480,6 +2542,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_Bio-Type_value_as_IR_instead_of_Iris: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2524,6 +2587,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_With_VID_invalid_Bio-Type_value_as_FIR_instead_of_Finger: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2568,6 +2632,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_With_UIN_invalid_Bio-Type_value_as_FIR_instead_of_Finger: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2612,6 +2677,7 @@ MultiFactorAuth: auth_MultiFactorAuth_with_uin_invalid_partner: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error diff --git a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml index 2826cef775f..1925587a476 100644 --- a/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml +++ b/automationtests/src/main/resources/ida/OtpAuth/OtpAuth.yml @@ -2,6 +2,7 @@ OtpAuth: auth_OTP_Auth_With_Valid_UIN_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -24,6 +25,7 @@ OtpAuth: auth_OTP_Auth_With_Valid_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -46,6 +48,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_Past_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2022-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -68,6 +71,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_Past_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2022-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -90,6 +94,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_Future_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2052-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -112,6 +117,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_Future_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2052-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -134,6 +140,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_Empty_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -156,6 +163,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_Empty_Timestamp_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -178,6 +186,7 @@ OtpAuth: auth_OTP_Auth_With_revoke_VID_Smoke_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_to_revoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -206,6 +215,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_individualId_UIN_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=@@###cndjdhe77473838&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -233,6 +243,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_individualId_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=@@###cndjdhe77473838&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -260,6 +271,7 @@ OtpAuth: auth_OTP_Auth_With_Blank_individualId_uin_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -287,6 +299,7 @@ OtpAuth: auth_OTP_Auth_With_Blank_individualId_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -314,6 +327,7 @@ OtpAuth: auth_OTP_Auth_With_Missing_individualId_uin_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&transactionId=$TRANSACTIONID$&certsDir=$CERTSDIR$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -341,6 +355,7 @@ OtpAuth: auth_OTP_Auth_With_Missing_individualId_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error @@ -368,6 +383,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=76544ddffgg@@@3444&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -389,6 +405,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_transactionId_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=76544ddffgg@@@3444&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -410,6 +427,7 @@ OtpAuth: auth_OTP_Auth_With_Blank_transactionId_uin_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -431,6 +449,7 @@ OtpAuth: auth_OTP_Auth_With_Blank_transactionId_VID_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -452,6 +471,7 @@ OtpAuth: auth_OTP_Auth_With_different_transactionId_uin_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=76544ddffgg@@@3444&id=$ID:AddIdentity_For_Otp_Auth_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -473,6 +493,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_individualIdType_VID_neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=ndjshswhw3277272&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -494,6 +515,7 @@ OtpAuth: auth_OTP_Auth_With_Blank_individualIdType_VID_Pos: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -515,6 +537,7 @@ OtpAuth: auth_OTP_Auth_With_Missing_Optional_Field_individualIdType_VID: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/OtpAuthResult @@ -536,6 +559,7 @@ OtpAuth: auth_OTP_Auth_With_Invalid_uin_partner: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_withValidParameters_smoke_Pos_UIN$&partnerUrlSuffix=zY22wDwZxwMdlxTZRWrM50m4zBoOiMyUGY/45362768/27822828287&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/OtpAuth/OtpAuth outputTemplate: ida/OtpAuth/error diff --git a/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs b/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs index 1e2ddabc7ec..bafa2f82a1c 100644 --- a/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs +++ b/automationtests/src/main/resources/ida/RevokeVID/createRevokeVIDResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.resident.vidstatus", - "version": "v1", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "message": "{{message}}" diff --git a/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs b/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs index 555ca559a54..0668a51b54b 100644 --- a/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs +++ b/automationtests/src/main/resources/ida/SendOTP/createSendOTPResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.identity.otp.internal", - "version": "1.0", + "id": "$IGNORE$", + "version": "$IGNORE$", "responseTime": "$IGNORE$", "transactionID": "$IGNORE$", "metadata": "$IGNORE$", From 204484eeb8adea553f836f763d052a4815f58fe3 Mon Sep 17 00:00:00 2001 From: Sohan Kumar Dey <72375959+Sohandey@users.noreply.github.com> Date: Fri, 18 Aug 2023 20:04:39 +0530 Subject: [PATCH 047/204] MOSIP-28845 --- .../apirig/admin/fw/util/AdminTestUtil.java | 108 +++++++++++++++--- .../testrig/apirig/service/BaseTestCase.java | 11 +- .../apirig/testrunner/MosipTestRunner.java | 85 +++++++------- .../resources/config/application.properties | 4 +- .../masterdata/Holiday/CreateHoliday.yml | 16 +-- .../masterdata/Holiday/UpdateHoliday.yml | 16 +-- .../LocationData/CreateLocationData.yml | 38 +++--- .../LocationData/UpdateLocationData.yml | 58 +++++----- .../CreateRegistrationCenter.yml | 14 +-- .../UpdateRegistrationCenter.yml | 14 +-- 10 files changed, 224 insertions(+), 140 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 81dae1b4106..2123d2886f1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -2740,6 +2740,27 @@ public String inputJsonKeyWordHandeler(String jsonString, String testCaseName) { if (jsonString.contains("$MISPPARTNEREMAIL$")) jsonString = replaceKeywordWithValue(jsonString, "$MISPPARTNEREMAIL$", genMispPartnerEmail); + + + + + if (jsonString.contains("$LOCATIONCODE$")) + jsonString = replaceKeywordWithValue(jsonString, "$LOCATIONCODE$", locationCode); + + + //Need to handle int replacement + //if (jsonString.contains("$HIERARCHYLEVEL$")) + //jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYLEVEL$", hierarchyLevel); + + if (jsonString.contains("$HIERARCHYNAME$")) + jsonString = replaceKeywordWithValue(jsonString, "$HIERARCHYNAME$", hierarchyName); + + if (jsonString.contains("$PARENTLOCCODE$")) + jsonString = replaceKeywordWithValue(jsonString, "$PARENTLOCCODE$", parentLocCode); + + + + if (jsonString.contains("$CACERT$")) { JSONObject request = new JSONObject(jsonString); @@ -4970,13 +4991,12 @@ public static String getCommitDetails(String path) { return path + "- No Response"; } - public static String getLocationData() { + public static void getLocationData() { Response response = null; JSONObject responseJson = null; String url = ApplnURI + props.getProperty("fetchLocationData"); String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); - String waitInterval = null; try { response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); @@ -4988,36 +5008,96 @@ public static String getLocationData() { JSONArray data = responseObject.getJSONArray("data"); - // Initialize variables for a, b, and c - String a = ""; - int b = -1; - String c = ""; for (int i = 0; i < data.length(); i++) { JSONObject entry = data.getJSONObject(i); String langCode = entry.getString("langCode"); if (BaseTestCase.languageList.get(0).equals(langCode)) { - a = entry.getString("hierarchyName"); - b = entry.getInt("hierarchyLevel"); - c = entry.optString("parentLocCode", ""); + hierarchyName = entry.getString("hierarchyName"); + hierarchyLevel = entry.getInt("hierarchyLevel"); + parentLocCode = entry.optString("parentLocCode", ""); break; } } - System.out.println("a: " + a); - System.out.println("b: " + b); - System.out.println("c: " + c); } catch (Exception e) { logger.error(e.getMessage()); } - return waitInterval; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); - return waitInterval; + } + } + + +public static void getLocationLevelData() { + + Response response = null; + JSONObject responseJson = null; + String url = ApplnURI + props.getProperty("fetchLocationLevel") + BaseTestCase.getLanguageList().get(0); + String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); + + + try { + + response = RestClient.getRequestWithCookie(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, + GlobalConstants.AUTHORIZATION, token); + + responseJson = new JSONObject(response.getBody().asString()); + + try { + JSONObject responseObject = responseJson.getJSONObject("response"); + JSONArray data = responseObject.getJSONArray("locations"); + + JSONObject entry = data.getJSONObject(0); + locationCode = entry.getString("code"); + + } catch (Exception e) { + logger.error(e.getMessage()); + } + + } catch (Exception e) { + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); + } + } + + + public static void getZoneName() { + + Response response = null; + JSONObject responseJson = null; + String url = ApplnURI + props.getProperty("fetchZone"); + String token = kernelAuthLib.getTokenByRole(GlobalConstants.ADMIN); + + + HashMap map = new HashMap<>(); + map.put("userID", ConfigManager.getUserAdminName()); + map.put("langCode", BaseTestCase.getLanguageList().get(0)); + + + try { + + response = RestClient.getRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); + + responseJson = new JSONObject(response.getBody().asString()); + + try { + JSONObject responseObject = responseJson.getJSONObject("response"); + JSONArray data = responseObject.getJSONArray("locations"); + + JSONObject entry = data.getJSONObject(0); + locationCode = entry.getString("code"); + + } catch (Exception e) { + logger.error(e.getMessage()); + } + + } catch (Exception e) { + logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 7da0777a3da..42e583af392 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -125,7 +125,14 @@ public class BaseTestCase { private static final char[] nNumericAllowed = "0123456789".toCharArray(); public static SecureRandom secureRandom = new SecureRandom(); - public static String currentRunningLanguage = ""; + public static String hierarchyName = ""; + public static int hierarchyLevel = 0; + public static String parentLocCode = ""; + + public static String locationCode = ""; + + + public static String genRid = "27847" + generateRandomNumberString(10); public static String genPolicyNumber = "9" + generateRandomNumberString(5); @@ -164,6 +171,8 @@ public class BaseTestCase { MosipTestRunner.getResourcePath() + "/" + "config/application.properties"); public static Properties propsKernel = getproperty( MosipTestRunner.getResourcePath() + "/" + "config/Kernel.properties"); + + public static String currentRunningLanguage = ""; public static String getOSType() { String type = System.getProperty("os.name"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 3acf50f1c82..3fe7fe135e6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -39,8 +39,6 @@ */ public class MosipTestRunner { private static final Logger LOGGER = Logger.getLogger(MosipTestRunner.class); - - public static String jarUrl = MosipTestRunner.class.getProtectionDomain().getCodeSource().getLocation().getPath(); public static List languageList = new ArrayList<>(); @@ -64,10 +62,10 @@ public static void main(String[] arg) { ExtractResource.removeOldMosipTestTestResource(); ExtractResource.extractResourceFromJar(); } - ConfigManager.init(); + ConfigManager.init(); BaseTestCase.suiteSetup(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); - + // For now we are not doing health check for qa-115. if (BaseTestCase.isTargetEnvLTS()) { HealthChecker healthcheck = new HealthChecker(); @@ -76,11 +74,9 @@ public static void main(String[] arg) { trigger.start(); } KeycloakUserManager.removeUser(); - KeycloakUserManager.createUsers(); - - + KeycloakUserManager.createUsers(); + List localLanguageList = new ArrayList<>(BaseTestCase.getLanguageList()); - AdminTestUtil.getLocationData(); String partnerKeyURL = ""; @@ -93,10 +89,9 @@ public static void main(String[] arg) { } - - - if (BaseTestCase.listOfModules.contains(GlobalConstants.MASTERDATA)) { + AdminTestUtil.getLocationData(); + AdminTestUtil.getLocationLevelData(); BaseTestCase.mapUserToZone(); BaseTestCase.mapZone(); @@ -125,7 +120,7 @@ public static void main(String[] arg) { } MockSMTPListener.bTerminate = true; - + if (BaseTestCase.isTargetEnvLTS()) HealthChecker.bTerminate = true; @@ -148,8 +143,7 @@ public static void startTestRunner() { if (checkRunType().contains("IDE") || os.toLowerCase().contains("windows")) { homeDir = new File(System.getProperty("user.dir") + "/testNgXmlFiles"); LOGGER.info("IDE :" + homeDir); - } - else { + } else { File dir = new File(System.getProperty("user.dir")); homeDir = new File(dir.getParent() + "/mosip/testNgXmlFiles"); LOGGER.info("ELSE :" + homeDir); @@ -198,7 +192,7 @@ public static String getResourcePath() { } return "Global Resource File Path Not Found"; } - + public static String generatePulicKey() { String publicKey = null; try { @@ -211,32 +205,32 @@ public static String generatePulicKey() { } return publicKey; } - + public static String generatePublicKeyForMimoto() { - KeyPairGenerator keyPairGen; - String vcString = ""; - try { - keyPairGen = KeyPairGenerator.getInstance("RSA"); - keyPairGen.initialize(2048); - KeyPair keyPair = keyPairGen.generateKeyPair(); - PublicKey publicKey = keyPair.getPublic(); - StringWriter stringWriter = new StringWriter(); - try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) { - pemWriter.writeObject(publicKey); - pemWriter.flush(); - vcString = stringWriter.toString(); - if (System.getProperty("os.name").toLowerCase().contains("windows")) { - vcString = vcString.replaceAll("\r\n", "\\\\n"); - } else { - vcString = vcString.replaceAll("\n", "\\\\n"); - } - } catch (Exception e) { - throw e; - } - } catch (Exception e) { - LOGGER.error(e.getMessage()); - } - return vcString; + KeyPairGenerator keyPairGen; + String vcString = ""; + try { + keyPairGen = KeyPairGenerator.getInstance("RSA"); + keyPairGen.initialize(2048); + KeyPair keyPair = keyPairGen.generateKeyPair(); + PublicKey publicKey = keyPair.getPublic(); + StringWriter stringWriter = new StringWriter(); + try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) { + pemWriter.writeObject(publicKey); + pemWriter.flush(); + vcString = stringWriter.toString(); + if (System.getProperty("os.name").toLowerCase().contains("windows")) { + vcString = vcString.replaceAll("\r\n", "\\\\n"); + } else { + vcString = vcString.replaceAll("\n", "\\\\n"); + } + } catch (Exception e) { + throw e; + } + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + return vcString; } public static String generateJWKPublicKey() { @@ -244,17 +238,16 @@ public static String generateJWKPublicKey() { KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance("RSA"); keyGenerator.initialize(2048, BaseTestCase.secureRandom); final KeyPair keypair = keyGenerator.generateKeyPair(); - RSAKey jwk = new RSAKey.Builder((RSAPublicKey) keypair.getPublic()).keyID("RSAKeyID").keyUse(KeyUse.SIGNATURE) - .privateKey(keypair.getPrivate()) - .build(); - + RSAKey jwk = new RSAKey.Builder((RSAPublicKey) keypair.getPublic()).keyID("RSAKeyID") + .keyUse(KeyUse.SIGNATURE).privateKey(keypair.getPrivate()).build(); + return jwk.toJSONString(); } catch (NoSuchAlgorithmException e) { LOGGER.error(e.getMessage()); return null; } } - + public static Properties getproperty(String path) { Properties prop = new Properties(); FileInputStream inputStream = null; @@ -264,7 +257,7 @@ public static Properties getproperty(String path) { prop.load(inputStream); } catch (Exception e) { LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); - }finally { + } finally { AdminTestUtil.closeInputStream(inputStream); } return prop; diff --git a/automationtests/src/main/resources/config/application.properties b/automationtests/src/main/resources/config/application.properties index 1ed6454312b..9ae511c5394 100644 --- a/automationtests/src/main/resources/config/application.properties +++ b/automationtests/src/main/resources/config/application.properties @@ -74,4 +74,6 @@ prerequisiteAutoGeneratedIdPropFileName=/prerequisite/autoGeneratedId.properties regProcAutoGeneratedIdPropFileName=/regProc/autoGeneratedId.properties mobileIdAutoGeneratedIdPropFileName=/mobileId/autoGeneratedId.properties fetchLocationData=/v1/masterdata/locations/all -fetchTitle=/v1/masterdata/title \ No newline at end of file +fetchLocationLevel=/v1/masterdata/locations/level/ +fetchTitle=/v1/masterdata/title +fetchZone=/v1/masterdata/zones/zonename \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml b/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml index 6c448c25cdb..17348f93564 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml +++ b/automationtests/src/main/resources/masterdata/Holiday/CreateHoliday.yml @@ -13,11 +13,11 @@ CreateHoliday: "holidayName": "AutoTest user Eng", "isActive": true, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ - "locationCode": "KTA", + "locationCode": "$IGNORE$", "holidayDate": "2020-08-15", "holidayName": "AutoTest user Eng", "langCode": "eng" @@ -36,7 +36,7 @@ CreateHoliday: "holidayName": "AutoTest user", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -61,7 +61,7 @@ CreateHoliday: "holidayName": "AutoTest user", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -86,7 +86,7 @@ CreateHoliday: "holidayName": "AutoTest user", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -111,7 +111,7 @@ CreateHoliday: "holidayName": "$REMOVE$", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -136,7 +136,7 @@ CreateHoliday: "holidayName": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -238,7 +238,7 @@ CreateHoliday: "holidayName": "AutoTest user", "isActive": "$REMOVE$", "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ diff --git a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml index 29100459110..e7ce4bbba98 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml +++ b/automationtests/src/main/resources/masterdata/Holiday/UpdateHoliday.yml @@ -13,12 +13,12 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": true, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ "holidayId": $IGNORE$, - "locationCode": "KTA", + "locationCode": "$IGNORE$", "holidayDate": "2020-08-15", "holidayName": "AutoTest user", "langCode": "eng" @@ -37,7 +37,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -62,7 +62,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -87,7 +87,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -112,7 +112,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -137,7 +137,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "KTA", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ @@ -187,7 +187,7 @@ UpdateHoliday: "holidayId": "$ID:CreateHoliday_All_Valid_Smoke_sid_holidayId$", "isActive": false, "langCode": "eng", - "locationCode": "GST", + "locationCode": "$LOCATIONCODE$", "requesttime": "$TIMESTAMP$" }' output: '{ diff --git a/automationtests/src/main/resources/masterdata/LocationData/CreateLocationData.yml b/automationtests/src/main/resources/masterdata/LocationData/CreateLocationData.yml index be8d94fe22d..22534cd1fa2 100644 --- a/automationtests/src/main/resources/masterdata/LocationData/CreateLocationData.yml +++ b/automationtests/src/main/resources/masterdata/LocationData/CreateLocationData.yml @@ -9,9 +9,9 @@ CreateLocationData: input: '{ "code": "TST12", "name": "Test_Loc_A_", - "hierarchyLevel": "4", - "hierarchyName": "City", - "parentLocCode": "KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": true, "requesttime": "$TIMESTAMP$" @@ -20,7 +20,7 @@ CreateLocationData: "isActive": "$IGNORE$", "code": "TST12", "name": "Test_Loc_A_", -"hierarchyLevel": "4", +"hierarchyLevel": "$IGNORE$", "hierarchyName": "$IGNORE$", "parentLocCode": "$IGNORE$", "langCode": "$IGNORE$" @@ -36,8 +36,8 @@ CreateLocationData: "code": "", "name": "Test_Loc_1_A", "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyName":"$HIERARCHYNAME$", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -61,8 +61,8 @@ CreateLocationData: "code": "NST", "name": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxy", "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyName":"$HIERARCHYNAME$", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -86,8 +86,8 @@ CreateLocationData: "code": "NST", "name": "", "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyName":"$HIERARCHYNAME$", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -111,8 +111,8 @@ CreateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"2147483647", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyName":"$HIERARCHYNAME$", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -136,8 +136,8 @@ CreateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"11", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyName":"$HIERARCHYNAME$", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -162,7 +162,7 @@ CreateLocationData: "name": "NDATA", "hierarchyLevel":"3", "hierarchyName":"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", - "parentLocCode":"KNT", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -187,7 +187,7 @@ CreateLocationData: "name": "NDATA", "hierarchyLevel":"3", "hierarchyName":"", - "parentLocCode":"KNT", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -211,7 +211,7 @@ CreateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"4", - "hierarchyName":"TestZone", + "hierarchyName":"$HIERARCHYNAME$", "parentLocCode":"fbheafg", "langCode": "eng", "isActive": false, @@ -238,8 +238,8 @@ CreateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"3", - "hierarchyName":"City", - "parentLocCode":"KNT", + "hierarchyName":"$HIERARCHYNAME$", + "parentLocCode":"$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "2019/12/20" diff --git a/automationtests/src/main/resources/masterdata/LocationData/UpdateLocationData.yml b/automationtests/src/main/resources/masterdata/LocationData/UpdateLocationData.yml index 602f99e75ec..3ed28691305 100644 --- a/automationtests/src/main/resources/masterdata/LocationData/UpdateLocationData.yml +++ b/automationtests/src/main/resources/masterdata/LocationData/UpdateLocationData.yml @@ -9,9 +9,9 @@ UpdateLocationData: input: '{ "code": "TST12", "name": "Test_Loc_A_updated", - "hierarchyLevel": "4", - "hierarchyName": "City", - "parentLocCode": "KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": true, "requesttime": "$TIMESTAMP$" @@ -35,9 +35,9 @@ UpdateLocationData: input: '{ "code": "anyString", "name": "Test_Loc_B_2", - "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -60,9 +60,9 @@ UpdateLocationData: input: '{ "code": "", "name": "Test_Loc_1_A", - "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -85,9 +85,9 @@ UpdateLocationData: input: '{ "code": "NST", "name": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxy", - "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -110,9 +110,9 @@ UpdateLocationData: input: '{ "code": "NST", "name": "", - "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -136,8 +136,8 @@ UpdateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"2147483647", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -160,9 +160,9 @@ UpdateLocationData: input: '{ "code": "NST", "name": "NDATA", - "hierarchyLevel":"11", - "hierarchyName":"TestZone", - "parentLocCode":"KNT", + "hierarchyLevel": "0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -185,9 +185,9 @@ UpdateLocationData: input: '{ "code": "NST", "name": "NDATA", - "hierarchyLevel":"3", + "hierarchyLevel": "0", "hierarchyName":"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm", - "parentLocCode":"KNT", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -211,8 +211,8 @@ UpdateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"3", - "hierarchyName":"", - "parentLocCode":"KNT", + "hierarchyName": "", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -236,8 +236,8 @@ UpdateLocationData: "code": "NST", "name": "NDATA", "hierarchyLevel":"4", - "hierarchyName":"TestZone", - "parentLocCode":"fbheafg", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "ENTLOCCOD", "langCode": "eng", "isActive": false, "requesttime": "$TIMESTAMP$" @@ -262,9 +262,9 @@ UpdateLocationData: input: '{ "code": "NST", "name": "NDATA", - "hierarchyLevel":"3", - "hierarchyName":"City", - "parentLocCode":"KNT", + "hierarchyLevel":"0", + "hierarchyName": "$HIERARCHYNAME$", + "parentLocCode": "$PARENTLOCCODE$", "langCode": "eng", "isActive": false, "requesttime": "2019/12/20" diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml b/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml index bcabbcb6b81..4bf159b37ff 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/CreateRegistrationCenter.yml @@ -15,10 +15,10 @@ CreateRegistrationCenter: "centerTypeCode":"REG", "contactPerson":"rtestsd", "contactPhone":"", - "holidayLocationCode":"RSK", + "holidayLocationCode":"$LOCATIONCODE$", "langCode":"hin", "latitude":"78.5478", - "locationCode":"14080", + "locationCode":"$LOCATIONCODE$", "longitude":"45.2456", "lunchEndTime":"00:00:00", "lunchStartTime":"00:00:00", @@ -59,7 +59,7 @@ CreateRegistrationCenter: "isActive": true, "langCode": "eng", "latitude": "33.995612", - "locationCode": "TST", + "locationCode": "$LOCATIONCODE$", "longitude": "-6.815281", "lunchEndTime": "14:00:00", "lunchStartTime": "13:00:00", @@ -99,11 +99,11 @@ CreateRegistrationCenter: "centerTypeCode": "ALT-3", "contactPerson": "Venkat TestPerson", "contactPhone": "9663089998", - "holidayLocationCode": "RBT", + "holidayLocationCode": "$LOCATIONCODE$", "isActive": true, "langCode": "eng", "latitude": "", - "locationCode": "TST", + "locationCode": "$LOCATIONCODE$", "longitude": "-6.815281", "lunchEndTime": "14:00:00", "lunchStartTime": "13:00:00", @@ -142,11 +142,11 @@ CreateRegistrationCenter: "centerTypeCode": "ALT-3", "contactPerson": "Venkat TestPerson", "contactPhone": "9663089998", - "holidayLocationCode": "RBT", + "holidayLocationCode": "$LOCATIONCODE$", "isActive": true, "langCode": "eng", "latitude": "fbheafg", - "locationCode": "14023", + "locationCode": "$LOCATIONCODE$", "longitude": "-6.8152", "lunchEndTime": "14:00:00", "lunchStartTime": "13:00:00", diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml b/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml index 6b8765be91d..36cbea20f16 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml +++ b/automationtests/src/main/resources/masterdata/RegistrationCenter/UpdateRegistrationCenter.yml @@ -15,11 +15,11 @@ UpdateRegistrationCenter: "centerTypeCode": "REG", "contactPerson": "Venkat TestPerson", "contactPhone": "9663089998", - "holidayLocationCode": "RBT", + "holidayLocationCode": "$LOCATIONCODE$", "isActive": true, "langCode": "eng", "latitude":"78.5478", - "locationCode":"14080", + "locationCode":"$LOCATIONCODE$", "longitude":"45.2456", "lunchEndTime":"00:00:00", "lunchStartTime":"00:00:00", @@ -57,7 +57,7 @@ UpdateRegistrationCenter: "isActive": true, "langCode": "eng", "latitude": "33.995612", - "locationCode": "TST", + "locationCode": "$LOCATIONCODE$", "longitude": "-6.815281", "lunchEndTime": "14:00:00", "lunchStartTime": "13:00:00", @@ -97,11 +97,11 @@ UpdateRegistrationCenter: "centerTypeCode": "REG", "contactPerson": "Venkat TestPerson", "contactPhone": "9663089998", - "holidayLocationCode": "RBT", + "holidayLocationCode": "$LOCATIONCODE$", "isActive": true, "langCode": "eng", "latitude": "", - "locationCode": "TST", + "locationCode": "$LOCATIONCODE$", "longitude": "-6.815281", "lunchEndTime": "14:00:00", "lunchStartTime": "13:00:00", @@ -140,11 +140,11 @@ UpdateRegistrationCenter: "centerTypeCode": "REG", "contactPerson": "Venkat TestPerson", "contactPhone": "9663089998", - "holidayLocationCode": "RBT", + "holidayLocationCode": "$LOCATIONCODE$", "isActive": true, "langCode": "eng", "latitude": "fbheafg", - "locationCode": "14023", + "locationCode": "$LOCATIONCODE$", "longitude": "-6.815281", "lunchEndTime": "14:00:00", "lunchStartTime": "13:00:00", From ef872157c22b152e07ce32d147e6bcb92385ff27 Mon Sep 17 00:00:00 2001 From: Pankaj Godiyal Date: Sat, 19 Aug 2023 10:47:31 +0530 Subject: [PATCH 048/204] Changed return type of getLangSelect from String to int --- .../io/mosip/testrig/apirig/kernel/util/ConfigManager.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index de5bf0aab56..18f71abbcca 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -429,8 +429,8 @@ public static String getAuthDemoServiceBaseUrl() { } - public static String getLangselect() { - return langselect; + public static int getLangselect() { + return Integer.parseInt(langselect); } From 909f5edc0f6fdb8687ad6ccf266e9815a5e77b51 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 21 Aug 2023 13:43:05 +0530 Subject: [PATCH 049/204] MOSIP-28922 --- .../fw/util/OutputValidationUtil.java | 2 + .../resident/AuthHistory/AuthHistory.yml | 1 + .../resident/AuthLock/createAuthLock.yml | 10 +- .../resident/AuthUnLock/createAuthUnLock.yml | 6 + .../AuthenticateUser/AuthenticateUser.yml | 2 + .../AuthorizationCode/AuthorizationCode.yml | 2 + .../GetCredentialTypes/GetCredentialTypes.yml | 6 +- .../RequestCredentials/ReqCredential.yml | 8 +- .../GenerateVID/createGenerateVID.yml | 1 + .../GenerateVID/createGenerateVIDNew.yml | 16 ++- ...lTemplateBylangCodeAndTemplateTypeCode.yml | 7 +- .../GetChannelVerificationStatus.yml | 3 + ...tCoordinateSpecificRegistrationCenters.yml | 71 ++--------- .../GetDocumentTypes/GetDocumentTypes.yml | 5 + ...tImmediateChildrenByLocCodeAndLangCode.yml | 11 +- ...GetLocationDetailsByLocCodeAndLangCode.yml | 10 +- .../GetLocationHierarchyByLangCode.yml | 6 +- .../GetNotifications/GetNotifications.yml | 14 +- .../GetPartnersByPartnerType.yml | 6 + ...etRegCenterByLangCodeAndHierarchyLevel.yml | 19 +-- ...CenterByHierarchyLevelAndTextPaginated.yml | 20 +-- .../GetRegistrationCenterWorkingDays.yml | 10 +- ...ainingupdatecountbyIndividualIdRequest.yml | 13 +- ...updatecountbyIndividualIdRequestResult.hbs | 4 +- .../GetResidentValidDocuments.yml | 11 +- .../GetUiProperties/GetUiProperties.yml | 1 + .../GetValidDocumentByLangCode.yml | 8 +- .../OAuthDetailsRequest.yml | 2 + .../PRINTUIN/createPrintUinResult.hbs | 6 +- .../RevokeVIDNew/CreateRevokeVIDNew.yml | 2 +- .../RidCheckStatus/createRidCheckStatus.yml | 1 + .../resources/resident/SendOTP/SendOTP.yml | 1 + .../resources/resident/SignJWT/SignJWT.yml | 1 + .../UpdateContactDetails.yml | 7 +- .../UpdateContactDetailsResult.hbs | 2 +- .../ValidateWithUserIdOtp.yml | 120 ++++++++++++++++-- 36 files changed, 265 insertions(+), 150 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index 2ee8e7c5de0..d7ba0fbca6e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -455,6 +455,8 @@ public static Map> doJsonOutputValidation(Stri String expOutputJson, boolean checkErrorsOnlyInResponse, String context, boolean responseHasErrors) throws AdminTestException { if (doesResponseHasErrorCode(actualOutputJson, 500)) throw new AdminTestException("Internal Server Error. Hence marking the test case as failed"); + if (doesResponseHasErrorCode(actualOutputJson, 404)) + throw new AdminTestException("Server not found. Hence marking the test case as failed"); JsonPrecondtion jsonPrecondtion = new JsonPrecondtion(); Map actual = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(actualOutputJson); Map exp = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(expOutputJson); diff --git a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml index 27b1a14747d..4fd51049b71 100644 --- a/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml +++ b/automationtests/src/main/resources/resident/AuthHistory/AuthHistory.yml @@ -494,6 +494,7 @@ AuthHistory: Resident_AuthHistory_With_UIN_Email_smoke_Pos: endPoint: /resident/v1/req/auth-history role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthHistory/authHistory outputTemplate: resident/AuthHistory/authHistoryResult diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml index 49cf3e77a97..e6861ac11a1 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml @@ -331,12 +331,12 @@ AuthLock: "maskedEmail": "$IGNORE$" } }' - Resident_AuthLock_Missing_individualIdType_Neg: + Resident_AuthLock_Missing_individualIdType_Pos: endPoint: /resident/v1/req/auth-lock role: resident restMethod: post inputTemplate: resident/AuthLock/createAuthLock - outputTemplate: resident/error + outputTemplate: resident/AuthLock/createAuthLockResult input: '{ "transactionID": "$TRANSACTIONID$", "individualId": "$ID:AddIdentity_Positive_TRE_smoke_UIN$", @@ -1168,6 +1168,12 @@ AuthLock: } ], "sendOtpResp":{ + "errors": [ + { + "errorCode": "IDA-OTA-008", + "message": "$IGNORE$" + } + ], "sendOtpResTemplate":"resident/error" } }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml index 0f5f9ae8a2c..a0f974ab0d8 100644 --- a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml @@ -1566,6 +1566,12 @@ AuthUnlock: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-422", + "message": "OTP is invalid" + } + ], "sendOtpResp":{ "errors": [ { diff --git a/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUser.yml b/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUser.yml index cf469de3317..0ceac0b7681 100644 --- a/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUser.yml +++ b/automationtests/src/main/resources/resident/AuthenticateUser/AuthenticateUser.yml @@ -2,6 +2,7 @@ AuthenticateUser: Resident_ESignet_AuthenticateUserIDP_uin_Otp_Valid_Smoke: endPoint: /v1/esignet/authorization/authenticate role: resident + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/AuthenticateUser/AuthenticateUser @@ -34,6 +35,7 @@ AuthenticateUser: Resident_ESignet_AuthenticateUserIDP_vid_Otp_Valid_Smoke: endPoint: /v1/esignet/authorization/authenticate role: resident + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/AuthenticateUser/AuthenticateUser diff --git a/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml b/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml index ee42ae15e62..ef8995da502 100644 --- a/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml +++ b/automationtests/src/main/resources/resident/AuthorizationCode/AuthorizationCode.yml @@ -2,6 +2,7 @@ AuthorizationCode: Resident_ESignet_AuthorizationCode_uin_All_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/AuthorizationCode/AuthorizationCode @@ -20,6 +21,7 @@ AuthorizationCode: Resident_ESignet_AuthorizationCode_Vid_All_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/auth-code role: resident + checkErrorsOnlyInResponse: true validityCheckRequired: true restMethod: post inputTemplate: resident/AuthorizationCode/AuthorizationCode diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml b/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml index 3a98af6ecea..598d4973683 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/GetCredentialTypes/GetCredentialTypes.yml @@ -2,6 +2,7 @@ GetCredentialTypes: Resident_GetCredentialTypes_smoke: endPoint: /resident/v1/credential/types role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/CredentialIssuance/GetCredentialTypes/getCredentialTypes outputTemplate: resident/CredentialIssuance/GetCredentialTypes/getCredentialTypesResult @@ -15,13 +16,12 @@ GetCredentialTypes: Resident_GetCredentialTypes_all_valid_smoke: endPoint: /resident/v1/credential/types role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/CredentialIssuance/GetCredentialTypes/getCredentialTypes outputTemplate: resident/CredentialIssuance/GetCredentialTypes/getCredentialTypesResult input: '{ }' output: '{ -"response": [{ - "version": $IGNORE$ - }] + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml index c9d5cec69a1..10861aecc8d 100644 --- a/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml +++ b/automationtests/src/main/resources/resident/CredentialIssuance/RequestCredentials/ReqCredential.yml @@ -664,6 +664,7 @@ RequestCredentials: Resident_RequestCredentials_encrypt_false_smoke: endPoint: /resident/v1/req/credential role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/error @@ -1339,6 +1340,7 @@ RequestCredentials: Resident_RequestCredentials_Email_Channel_Pos: endPoint: /resident/v1/req/credential role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/CredentialIssuance/RequestCredentials/reqCredential outputTemplate: resident/CredentialIssuance/RequestCredentials/ReqCredentialResult @@ -1422,10 +1424,10 @@ RequestCredentials: } }' output: '{ - "errors": [ + "errors": [ { - "errorCode": "$IGNORE$", - "message": "$IGNORE$" + "errorCode": "RES-SER-422", + "message": "OTP is invalid" } ], "sendOtpResp":{ diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml index e0b4e6dc12a..909fa428c95 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVID.yml @@ -1816,6 +1816,7 @@ GenerateVID: Resident_Generate_Perpetual_VID_Email_Valid_Smoke_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/GenerateVID/createGenerateVID outputTemplate: resident/GenerateVID/createGenerateVIDResult diff --git a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml index 88969b451e3..47a32b95ecb 100644 --- a/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml +++ b/automationtests/src/main/resources/resident/GenerateVID/createGenerateVIDNew.yml @@ -381,7 +381,7 @@ GenerateVIDNew: "maskedEmail": "res***************@gmail.com" }' - Resident_Generate_Perpetual_VID_TransID_uin_Invalid_Pos: + Resident_Generate_Perpetual_VID_TransID_uin_Invalid: endPoint: /resident/v1/generate-vid role: residentNewVid restMethod: post @@ -395,7 +395,12 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - + "errors": [ + { + "errorCode": "RES-SER-513", + "message": "$IGNORE$" + } + ] }' Resident_Generate_Perpetual_VID_uin_EmptyChannel_Pos: @@ -412,7 +417,12 @@ GenerateVIDNew: "vidType": "Perpetual" }' output: '{ - + "errors": [ + { + "errorCode": "RES-SER-513", + "message": "$IGNORE$" + } + ] }' Resident_Generate_Perpetual_VID_uin_Empty_TransID_Invalid_Neg: diff --git a/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml b/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml index 497d3b84fe2..ac799fd354a 100644 --- a/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml +++ b/automationtests/src/main/resources/resident/GetAllTemplateBylangCodeAndTemplateTypeCode/GetAllTemplateBylangCodeAndTemplateTypeCode.yml @@ -90,7 +90,12 @@ GetAllTemplateBylangCodeAndTemplateTypeCode: "templatetypecode": "tnc-update-demo" }' output: '{ - + "errors": [ + { + "errorCode": "KER-ATH-401", + "message": "Authentication Failed" + } + ] }' Resident_GetAllTemplateBylangCodeAndTemplateTypeCode_vid_1_Valid_Smoke: diff --git a/automationtests/src/main/resources/resident/GetChannelVerificationStatus/GetChannelVerificationStatus.yml b/automationtests/src/main/resources/resident/GetChannelVerificationStatus/GetChannelVerificationStatus.yml index fcb11873025..809ba28269c 100644 --- a/automationtests/src/main/resources/resident/GetChannelVerificationStatus/GetChannelVerificationStatus.yml +++ b/automationtests/src/main/resources/resident/GetChannelVerificationStatus/GetChannelVerificationStatus.yml @@ -2,6 +2,7 @@ GetChannelVerificationStatus: Resident_GetChannelVerificationStatus_For_Email_Valid_Smoke: endPoint: /resident/v1/channel/verification-status/?channel={channel}&individualId={individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetChannelVerificationStatus/getChannelVerificationStatus outputTemplate: resident/GetChannelVerificationStatus/getChannelVerificationStatusResult @@ -262,6 +263,7 @@ GetChannelVerificationStatus: Resident_GetChannelVerificationStatus_Email_Valid_Smoke: endPoint: /resident/v1/channel/verification-status/?channel={channel}&individualId={individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetChannelVerificationStatus/getChannelVerificationStatus outputTemplate: resident/GetChannelVerificationStatus/getChannelVerificationStatusResult @@ -382,6 +384,7 @@ GetChannelVerificationStatus: Resident_GetChannelVerificationStatus_Phone_Invalid: endPoint: /resident/v1/channel/verification-status/?channel={channel}&individualId={individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetChannelVerificationStatus/getChannelVerificationStatus outputTemplate: resident/GetChannelVerificationStatus/getChannelVerificationStatusResult diff --git a/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml b/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml index 7e8511af2c4..207d191c0a1 100644 --- a/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml +++ b/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml @@ -2,6 +2,7 @@ GetCoordinateSpecificRegistrationCenters: Resident_GetCoordinateSpecificRegistrationCenters_allValid_smoke: endPoint: /resident/v1/proxy/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCenters outputTemplate: resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCentersResult @@ -12,31 +13,6 @@ GetCoordinateSpecificRegistrationCenters: "longitude": "-6.453275" }' output: '{ - "registrationCenters": [{ - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "{{latitude}}", - "longitude": "{{longitude}}", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" - }] }' @@ -150,6 +126,7 @@ GetCoordinateSpecificRegistrationCenters: Resident_GetCoordinateSpecificRegistrationCenters_Valid_smoke: endPoint: /resident/v1/proxy/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCenters outputTemplate: resident/GetCoordinateSpecificRegistrationCenters/getCoordinateSpecificRegistrationCentersResult @@ -160,31 +137,7 @@ GetCoordinateSpecificRegistrationCenters: "longitude": "-6.453275" }' output: '{ - "registrationCenters": [{ - "id": "$IGNORE$", - "name": "$IGNORE$", - "centerTypeCode": "$IGNORE$", - "addressLine1": "$IGNORE$", - "addressLine2": "$IGNORE$", - "addressLine3": "$IGNORE$", - "latitude": "{{latitude}}", - "longitude": "{{longitude}}", - "locationCode": "$IGNORE$", - "holidayLocationCode": "$IGNORE$", - "contactPhone": "$IGNORE$", - "workingHours": "$IGNORE$", - "langCode": "$IGNORE$", - "numberOfKiosks": "$IGNORE$", - "perKioskProcessTime": "$IGNORE$", - "centerStartTime": "$IGNORE$", - "centerEndTime": "$IGNORE$", - "timeZone": "$IGNORE$", - "contactPerson": "$IGNORE$", - "lunchStartTime": "$IGNORE$", - "lunchEndTime": "$IGNORE$", - "isActive": "$IGNORE$", - "zoneCode": "$IGNORE$" - }] + }' Resident_GetCoordinateSpecificRegistrationCenters_Invalid_langCode_Neg: @@ -272,7 +225,7 @@ GetCoordinateSpecificRegistrationCenters: ] }' - Resident_GetCoordinateSpecificRegistrationCenters_Empty_LangCode_Neg: + Resident_GetCoordinateSpecificRegistrationCenters_StatusCode_Empty_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} role: resident restMethod: get @@ -284,11 +237,9 @@ GetCoordinateSpecificRegistrationCenters: "proximitydistance": "21", "longitude": "-6.453275" }' - output: '{ - -}' + output: "404" - Resident_GetCoordinateSpecificRegistrationCenters_Empty_Latitude_Neg: + Resident_GetCoordinateSpecificRegistrationCenters_StatusCode_Empty_Latitude_Neg: endPoint: /resident/v1/proxy/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} role: resident restMethod: get @@ -300,11 +251,9 @@ GetCoordinateSpecificRegistrationCenters: "proximitydistance": "21", "longitude": "-6.453275" }' - output: '{ - -}' + output: "404" - Resident_GetCoordinateSpecificRegistrationCenters_Empty_Longitude_Neg: + Resident_GetCoordinateSpecificRegistrationCenters_StatusCode_Empty_Longitude_Neg: endPoint: /resident/v1/proxy/masterdata/getcoordinatespecificregistrationcenters/{langcode}/{longitude}/{latitude}/{proximitydistance} role: resident restMethod: get @@ -316,6 +265,4 @@ GetCoordinateSpecificRegistrationCenters: "proximitydistance": "21", "longitude": "" }' - output: '{ - -}' \ No newline at end of file + output: "404" \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypes.yml b/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypes.yml index f9b88461c60..9b957471f90 100644 --- a/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypes.yml +++ b/automationtests/src/main/resources/resident/GetDocumentTypes/GetDocumentTypes.yml @@ -2,6 +2,7 @@ GetDocumentTypes: Resident_GetGetDocumentTypes_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/documenttypes/{documentcategorycode}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetDocumentTypes/GetDocumentTypes outputTemplate: resident/GetDocumentTypes/GetDocumentTypesResult @@ -15,6 +16,7 @@ GetDocumentTypes: Resident_GetGetDocumentTypes1_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/documenttypes/{documentcategorycode}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetDocumentTypes/GetDocumentTypes outputTemplate: resident/GetDocumentTypes/GetDocumentTypesResult @@ -28,6 +30,7 @@ GetDocumentTypes: Resident_GetGetDocumentTypes2_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/documenttypes/{documentcategorycode}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetDocumentTypes/GetDocumentTypes outputTemplate: resident/GetDocumentTypes/GetDocumentTypesResult @@ -41,6 +44,7 @@ GetDocumentTypes: Resident_GetGetDocumentTypes3_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/documenttypes/{documentcategorycode}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetDocumentTypes/GetDocumentTypes outputTemplate: resident/GetDocumentTypes/GetDocumentTypesResult @@ -54,6 +58,7 @@ GetDocumentTypes: Resident_GetGetDocumentTypes4_all_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/documenttypes/{documentcategorycode}/{langcode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetDocumentTypes/GetDocumentTypes outputTemplate: resident/GetDocumentTypes/GetDocumentTypesResult diff --git a/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml b/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml index 362ac054ae9..55c26b68b9d 100644 --- a/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml +++ b/automationtests/src/main/resources/resident/GetImmediateChildrenByLocCodeAndLangCode/GetImmediateChildrenByLocCodeAndLangCode.yml @@ -59,7 +59,7 @@ GetImmediateChildrenByLocCodeAndLangCode: ] }' - Resident_GetImmediateChildrenByLocCodeAndLangCode_Empty_locationCode_Neg: + Resident_GetImmediateChildrenByLocCodeAndLangCode_StatusCode_Empty_locationCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident restMethod: get @@ -69,11 +69,9 @@ GetImmediateChildrenByLocCodeAndLangCode: "locationCode":"", "langCode":"abc" }' - output: '{ - -}' + output: "404" - Resident_GetImmediateChildrenByLocCodeAndLangCode_Empty_langCode_Neg: + Resident_GetImmediateChildrenByLocCodeAndLangCode_StatusCode_Empty_langCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/immediatechildren/{locationCode}/{langCode} role: resident restMethod: get @@ -83,5 +81,4 @@ GetImmediateChildrenByLocCodeAndLangCode: "locationCode":"KNT", "langCode":"" }' - output: '{ -}' \ No newline at end of file + output: "404" \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml b/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml index 5437ad9ba5c..6641616ade6 100644 --- a/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml +++ b/automationtests/src/main/resources/resident/GetLocationDetailsByLocCodeAndLangCode/GetLocationDetailsByLocCodeAndLangCode.yml @@ -70,7 +70,7 @@ GetLocationDetailsByLocCodeAndLangCode: ] }' - Resident_GetLocationDetailsByLocCodeAndLangCode_Empty_LangCode_Neg: + Resident_GetLocationDetailsByLocCodeAndLangCode_StatusCode_Empty_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident restMethod: get @@ -80,10 +80,9 @@ GetLocationDetailsByLocCodeAndLangCode: "langCode": "", "loccode": "14022" }' - output: '{ -}' + output: "404" - Resident_GetLocationDetailsByLocCodeAndLangCode_Empty_LocationCode_Neg: + Resident_GetLocationDetailsByLocCodeAndLangCode_StatusCode_Empty_LocationCode_Neg: endPoint: /resident/v1/proxy/masterdata/locations/info/{loccode}/{langCode} role: resident restMethod: get @@ -93,5 +92,4 @@ GetLocationDetailsByLocCodeAndLangCode: "langCode": "$1STLANG$", "loccode": "" }' - output: '{ -}' \ No newline at end of file + output: "404" \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml b/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml index 6efea89e592..c1646a1e358 100644 --- a/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml +++ b/automationtests/src/main/resources/resident/GetLocationHierarchyByLanguageCode/GetLocationHierarchyByLangCode.yml @@ -34,7 +34,7 @@ GetLocationHierarchyByLanguageCode: ] }' - Resident_GetLocationHierarchyByLanguageCode_Empty_LangCode_Neg: + Resident_GetLocationHierarchyByLanguageCode_StatusCode_Empty_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/locationHierarchyLevels/{langCode} role: resident restMethod: get @@ -43,6 +43,4 @@ GetLocationHierarchyByLanguageCode: input: '{ "langCode":"" }' - output: '{ - -}' \ No newline at end of file + output: "404" \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml b/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml index a9ca08c3df3..10cf32e9a9e 100644 --- a/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml +++ b/automationtests/src/main/resources/resident/GetNotifications/GetNotifications.yml @@ -357,7 +357,12 @@ GetNotifications: "pageFetch":"2" }' output: '{ - + "errors": [ + { + "errorCode": "RES-SER-446", + "message": "Invalid page start value" + } + ] }' Resident_GetNotifications_uin_Neg_Value_pageFetch_Neg: @@ -372,5 +377,10 @@ GetNotifications: "pageFetch":"-2" }' output: '{ - + "errors": [ + { + "errorCode": "RES-SER-447", + "message": "Invalid page fetch value" + } + ] }' \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml b/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml index 80418f4ea22..0522189cb34 100644 --- a/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml +++ b/automationtests/src/main/resources/resident/GetPartnersByPartnerType/GetPartnersByPartnerType.yml @@ -52,6 +52,12 @@ GetPartnersByPartnerType: "partnerType": "" }' output: '{ + "errors": [ + { + "errorCode": "KER-ATH-401", + "message": "Authentication Failed" + } + ] }' Resident_GetPartnersByPartnerType_vid_all_Valid_Smoke: diff --git a/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml b/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml index 53b59d9042a..2e794e655ae 100644 --- a/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml +++ b/automationtests/src/main/resources/resident/GetRegCenterByLangCodeAndHierarchyLevel/GetRegCenterByLangCodeAndHierarchyLevel.yml @@ -137,7 +137,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: ] }' - Resident_GetRegCenterByLangCodeAndHierarchyLevel_Empty_LangCode_MandatoryFields_Neg: + Resident_GetRegCenterByLangCodeAndHierarchyLevel_StatusCode_Empty_LangCode_MandatoryFields_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident restMethod: get @@ -148,11 +148,9 @@ GetRegCenterByLangCodeAndHierarchyLevel: "hierarchylevel": "5", "name": "10112" }' - output: '{ - -}' + output: "404" - Resident_GetRegCenterByLangCodeAndHierarchyLevel_Empty_Level_MandatoryFields_Neg: + Resident_GetRegCenterByLangCodeAndHierarchyLevel_StatusCode_Empty_Level_MandatoryFields_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} role: resident restMethod: get @@ -163,9 +161,7 @@ GetRegCenterByLangCodeAndHierarchyLevel: "hierarchylevel": "", "name": "10112" }' - output: '{ - -}' + output: "404" Resident_GetRegCenterByLangCodeAndHierarchyLevel_Empty_Name_MandatoryFields_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/{langcode}/{hierarchylevel}/names?name={name} @@ -179,7 +175,12 @@ GetRegCenterByLangCodeAndHierarchyLevel: "name": "" }' output: '{ - + "errors": [ + { + "errorCode": "RES-SER-418", + "message": "Registration Center not found" + } + ] }' Resident_GetRegCenterByLangCodeAndHierarchyLevel_0_all_Valid_Smoke: diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml b/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml index 9f4b87e7aed..1cbd5eb65a3 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterByHierarchyLevelAndTextPaginated/GetRegistrationCenterByHierarchyLevelAndTextPaginated.yml @@ -155,7 +155,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: output: '{ "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "RES-SER-418", "message": "$IGNORE$" } ] @@ -257,7 +257,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: ] }' - Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_LangCode_Empty_Neg: + Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_StatusCode_LangCode_Empty_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident restMethod: get @@ -272,11 +272,9 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: "sortBy":"createdDateTime", "orderBy":"desc" }' - output: '{ - -}' + output: "404" - Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_HierarchyLevel_Empty_Neg: + Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_StatusCode_HierarchyLevel_Empty_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident restMethod: get @@ -291,11 +289,9 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: "sortBy":"createdDateTime", "orderBy":"desc" }' - output: '{ - -}' + output: "404" - Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_Name_Empty_Neg: + Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_StatusCode_Name_Empty_Neg: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} role: resident restMethod: get @@ -310,9 +306,7 @@ GetRegistrationCenterByHierarchyLevelAndTextPaginated: "sortBy":"createdDateTime", "orderBy":"desc" }' - output: '{ - -}' + output: "404" Resident_GetRegistrationCenterByHierarchyLevelAndTextPaginated_0_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/registrationcenters/page/{langcode}/{hierarchylevel}/{name}?pageNumber={pageNumber}&pageSize={pageSize}&orderBy={orderBy}&sortBy={sortBy} diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml index 7571292eb30..92e96de501d 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml @@ -70,7 +70,7 @@ GetRegistrationCenterWorkingDays: ] }' - Resident_GetRegistrationCenterWorkingDays_Empty_registrationCenterID_Neg: + Resident_GetRegistrationCenterWorkingDays_StatusCode_Empty_registrationCenterID_Neg: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident templateFields: ["langCode"] @@ -81,10 +81,9 @@ GetRegistrationCenterWorkingDays: "langCode": "eng", "registrationCenterID": "" }' - output: '{ -}' + output: "404" - Resident_GetRegistrationCenterWorkingDays_Empty_langCode_Neg: + Resident_GetRegistrationCenterWorkingDays_StatusCode_Empty_langCode_Neg: endPoint: /resident/v1/proxy/masterdata/workingdays/{registrationCenterID}/{langCode} role: resident restMethod: get @@ -94,5 +93,4 @@ GetRegistrationCenterWorkingDays: "langCode": "", "registrationCenterID": "10011" }' - output: '{ -}' \ No newline at end of file + output: "404" \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml index 344d318b5d1..a2fa928d5d2 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequest.yml @@ -26,10 +26,15 @@ GetRemainingupdatecountbyIndividualIdRequest: "attribute_list": "fullName" }' output: '{ - + "errors": [ + { + "errorCode": "IDR-IDC-004", + "message": "Unknown error occurred" + } + ] }' - Resident_GetRemainingupdatecountby_empty_IndividualIdRequest_Negative: + Resident_GetRemainingupdatecountby_StatusCode_empty_IndividualIdRequest_Negative: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} role: resident restMethod: get @@ -40,9 +45,7 @@ GetRemainingupdatecountbyIndividualIdRequest: "idType": "UIN", "attribute_list": "fullName" }' - output: '{ - -}' + output: "404" Resident_GetRemainingupdatecountbyIndividualIdRequest_Invalid_Token: endPoint: /idrepository/v1/identity/{individualId}/update-counts?idType={idType}&attribute_list={attribute_list} diff --git a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs index e968fa180df..c8c7de1ec9b 100644 --- a/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs +++ b/automationtests/src/main/resources/resident/GetRemainingupdatecountbyIndividualIdRequest/GetRemainingupdatecountbyIndividualIdRequestResult.hbs @@ -1,6 +1,6 @@ { - "id": "mosip.id.read", - "version": "v1", + "id": "$IGNORE$", + "version": "$IGNORE$", "errors": "$IGNORE$", "response": "$IGNORE$", "responseTime": "$IGNORE$" diff --git a/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml b/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml index 35f9b05320e..791c234ed61 100644 --- a/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml +++ b/automationtests/src/main/resources/resident/GetResidentValidDocuments/GetResidentValidDocuments.yml @@ -66,9 +66,15 @@ GetResidentValidDocuments: "langCode":"" }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-418", + "message": "Error occurred while fetching Applicant Type-Document Category-Document Type Mapping details" + } + ] }' - Resident_GetResidentValidDocuments_Empty_ApplicantId_Neg: + Resident_GetResidentValidDocuments_StatusCode_Empty_ApplicantId_Neg: endPoint: /resident/v1/proxy/masterdata/applicanttype/{applicantId}/languages?languages={langCode} role: resident restMethod: get @@ -78,5 +84,4 @@ GetResidentValidDocuments: "applicantId": "", "langCode":"$1STLANG$" }' - output: '{ -}' \ No newline at end of file + output: "404" \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml b/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml index 46cbdbcc880..3e2c1d5166b 100644 --- a/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml +++ b/automationtests/src/main/resources/resident/GetUiProperties/GetUiProperties.yml @@ -2,6 +2,7 @@ GetUiProperties: Resident_GetUiProperties_all_Valid_Smoke: endPoint: /resident/v1/proxy/config/ui-properties role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetUiProperties/getUiProperties outputTemplate: resident/GetUiProperties/getUiPropertiesResult diff --git a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml index 389ee115107..489dae1b351 100644 --- a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml +++ b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml @@ -2,6 +2,7 @@ GetValidDocumentByLangCode: Resident_GetValidDocumentByLangCode_All_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCode outputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCodeResult @@ -49,7 +50,7 @@ GetValidDocumentByLangCode: }] }' - Resident_GetValidDocumentByLangCode_Empty_Invalid_Neg: + Resident_GetValidDocumentByLangCode_StatusCode_Empty_Invalid_Neg: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} role: resident restMethod: get @@ -58,10 +59,7 @@ GetValidDocumentByLangCode: input: '{ "langCode": "" }' - output: '{ - "error": "Not Found", - "message": "$IGNORE$" -}' + output: "404" Resident_GetValidDocumentByLangCode_Invalid_LangCode_Neg: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} diff --git a/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequest.yml b/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequest.yml index eed7fb75f9f..7cf9c65c442 100644 --- a/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequest.yml +++ b/automationtests/src/main/resources/resident/OAuthDetailsRequest/OAuthDetailsRequest.yml @@ -2,6 +2,7 @@ OAuthDetailsRequest: Resident_ESignet_OAuthDetailsRequest_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: resident/OAuthDetailsRequest/OAuthDetailsRequestResult @@ -26,6 +27,7 @@ OAuthDetailsRequest: Resident_ESignet_OAuthDetailsRequest_Vid_all_Valid_Smoke_sid: endPoint: /v1/esignet/authorization/oauth-details role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/OAuthDetailsRequest/OAuthDetailsRequest outputTemplate: resident/OAuthDetailsRequest/OAuthDetailsRequestResult diff --git a/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs b/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs index e25b38d21b5..c65f625f47b 100644 --- a/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs +++ b/automationtests/src/main/resources/resident/PRINTUIN/createPrintUinResult.hbs @@ -1,11 +1,11 @@ { - "id": "mosip.resident.printuin", - "version": "v1", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": null, "response": { "registrationId": "{{registrationId}}", "message": "{{message}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml index ba74dcf8c41..dd257b30fcd 100644 --- a/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml +++ b/automationtests/src/main/resources/resident/RevokeVIDNew/CreateRevokeVIDNew.yml @@ -124,7 +124,7 @@ RevokeVIDNew: output: '{ "errors": [ { - "errorCode": "RES-SER-406", + "errorCode": "RES-SER-454", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml index 259fb99818b..f8bd92eb49a 100644 --- a/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml +++ b/automationtests/src/main/resources/resident/RidCheckStatus/createRidCheckStatus.yml @@ -2,6 +2,7 @@ RidCheckStatus: Resident_RidCheckStatus_AllValid_Smoke: endPoint: /resident/v1/rid/check-status role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/RidCheckStatus/createRidCheckStatus outputTemplate: resident/RidCheckStatus/createRidCheckStatusResult diff --git a/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml b/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml index 398520c7fc5..e883236c369 100644 --- a/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml +++ b/automationtests/src/main/resources/resident/SendOTP/SendOTP.yml @@ -35,6 +35,7 @@ SendOTP: Resident_SendOTP_Valid_UIN_Email_Smoke: endPoint: /resident/v1/req/otp role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/SendOTP/createSendOTP2 outputTemplate: resident/SendOTP/createSendOTPResult diff --git a/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml b/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml index 0db511fd7bb..744ff04c35f 100644 --- a/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml +++ b/automationtests/src/main/resources/resident/SignJWT/SignJWT.yml @@ -2,6 +2,7 @@ SignJWT: Resident_SignJWT_all_Valid_Smoke_sid: endPoint: /v1/keymanager/jwtSign role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/SignJWT/SignJWT outputTemplate: resident/SignJWT/SignJWTResult diff --git a/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetails.yml b/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetails.yml index 7cb1148d2dc..f0fa77f6b4b 100644 --- a/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetails.yml +++ b/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetails.yml @@ -314,7 +314,12 @@ UpdateContactDetails: } ], "sendOtpResp":{ - "errorCode": "KER-ATH-401", + "errors": [ + { + "errorCode": "KER-ATH-401", + "message": "Authentication Failed" + } + ], "sendOtpResTemplate":"resident/error" } }' diff --git a/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs b/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs index 78362a91850..b3ec94d40d5 100644 --- a/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs +++ b/automationtests/src/main/resources/resident/UpdateContactDetails/UpdateContactDetailsResult.hbs @@ -3,7 +3,7 @@ "version": "1.0", "responsetime": "$IGNORE$", "response": { - "status": {{status}}, + "status": "{{status}}", "message": "$IGNORE$" }, "errors": "$IGNORE$" diff --git a/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml b/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml index 19e39bfdaf2..bfee10c6001 100644 --- a/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml +++ b/automationtests/src/main/resources/resident/ValidateWithUserIdOtp/ValidateWithUserIdOtp.yml @@ -152,10 +152,10 @@ ValidateWithUserIdOtp: } }' output: '{ - "errors": [ + "errors": [ { "errorCode": "RES-SER-410", - "message": "Invalid Input Parameter- userId" + "message": "$IGNORE$" } ], "sendOtpResp":{ @@ -319,6 +319,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -346,6 +352,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -373,13 +385,17 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", "sendOtpResTemplate":"resident/SendOtpToUserId/SendOtpToUserIdResult" - }, - "status": "Email Request submitted", - "message": "success" + } }' Resident_ValidateWithUserIdOtp_uin_Null_transactionID_Neg: @@ -402,6 +418,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -429,6 +451,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -456,6 +484,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -483,6 +517,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -510,6 +550,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -537,6 +583,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -865,6 +917,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -892,6 +950,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -919,13 +983,17 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", "sendOtpResTemplate":"resident/SendOtpToUserId/SendOtpToUserIdResult" - }, - "status": "Email Request submitted", - "message": "success" + } }' Resident_ValidateWithUserIdOtp_vid_Null_transactionID_Neg: @@ -948,6 +1016,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -975,6 +1049,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -1002,6 +1082,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -1029,6 +1115,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -1056,6 +1148,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", @@ -1083,6 +1181,12 @@ ValidateWithUserIdOtp: } }' output: '{ + "errors": [ + { + "errorCode": "RES-SER-410", + "message": "$IGNORE$" + } + ], "sendOtpResp":{ "status": "Email Request submitted", "message": "success", From ec7504e6ea80b9a20043c019877a4796f304d422 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 21 Aug 2023 13:49:13 +0530 Subject: [PATCH 050/204] MOSIP-28922 --- .../apirig/authentication/fw/util/OutputValidationUtil.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index d7ba0fbca6e..5278bcde8ed 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -456,7 +456,7 @@ public static Map> doJsonOutputValidation(Stri if (doesResponseHasErrorCode(actualOutputJson, 500)) throw new AdminTestException("Internal Server Error. Hence marking the test case as failed"); if (doesResponseHasErrorCode(actualOutputJson, 404)) - throw new AdminTestException("Server not found. Hence marking the test case as failed"); + throw new AdminTestException("Page not found. Hence marking the test case as failed"); JsonPrecondtion jsonPrecondtion = new JsonPrecondtion(); Map actual = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(actualOutputJson); Map exp = jsonPrecondtion.retrieveMappingAndItsValueToPerformJsonOutputValidation(expOutputJson); From f83dfc531b6a977a01a81d77d994e207c2484f4f Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 21 Aug 2023 16:10:39 +0530 Subject: [PATCH 051/204] MOSIP-29037 --- .../src/main/resources/ida/GenerateVID/createGenerateVID.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/automationtests/src/main/resources/ida/GenerateVID/createGenerateVID.yml b/automationtests/src/main/resources/ida/GenerateVID/createGenerateVID.yml index 29aabcfbffb..0480aaa95f1 100644 --- a/automationtests/src/main/resources/ida/GenerateVID/createGenerateVID.yml +++ b/automationtests/src/main/resources/ida/GenerateVID/createGenerateVID.yml @@ -2,6 +2,7 @@ GenerateVID: auth_GenerateVID_All_Valid_Smoke_Perpetual_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/GenerateVID/createGenerateVID outputTemplate: ida/GenerateVID/createGenerateVIDResult @@ -35,6 +36,7 @@ GenerateVID: auth_GenerateVID_to_revoke_Perpetual_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/GenerateVID/createGenerateVID outputTemplate: ida/GenerateVID/createGenerateVIDResult @@ -68,6 +70,7 @@ GenerateVID: auth_GenerateVID_to_test_hotlist_Perpetual_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/GenerateVID/createGenerateVID outputTemplate: ida/GenerateVID/createGenerateVIDResult @@ -101,6 +104,7 @@ GenerateVID: auth_GenerateVID_All_Valid_Smoke_Temp_VID_sid: endPoint: /resident/v1/vid role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/GenerateVID/createGenerateVID outputTemplate: ida/GenerateVID/createGenerateVIDResult From de55e3fa481860b24c8d7950c4f2a5bf088acec5 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 21 Aug 2023 17:56:01 +0530 Subject: [PATCH 052/204] MOSIP-29037 --- .../resources/ida/AuthTransaction/AuthTransaction.yml | 2 ++ .../resources/ida/BlockHotlistAPI/blockHotlistAPI.hbs | 2 +- .../src/main/resources/ida/EkycOtp/EkycOtp.yml | 2 +- .../resources/ida/MultiFactorAuth/MultiFactorAuth.yml | 8 ++++---- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml b/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml index bd252c58b6d..e4a0c090162 100644 --- a/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml +++ b/automationtests/src/main/resources/ida/AuthTransaction/AuthTransaction.yml @@ -2,6 +2,7 @@ AuthTransaction: auth_AuthTransaction_allValid_smoke_UIN: endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: ida/AuthTransaction/authTransaction outputTemplate: ida/AuthTransaction/authTransactionResult @@ -14,6 +15,7 @@ AuthTransaction: auth_AuthTransaction_allValid_smoke_VID: endPoint: /idauthentication/v1/internal/authTransactions/individualId/{individualId} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: ida/AuthTransaction/authTransaction outputTemplate: ida/AuthTransaction/authTransactionResult diff --git a/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPI.hbs b/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPI.hbs index 24746a1b216..fd272de5421 100644 --- a/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPI.hbs +++ b/automationtests/src/main/resources/ida/BlockHotlistAPI/blockHotlistAPI.hbs @@ -2,7 +2,7 @@ "request": { "id": "{{id}}", "idType": "{{idType}}", - "expiryTimestamp": null + "expiryTimestamp": "{{expiryTimestamp}}" }, "requesttime": "{{requesttime}}" } diff --git a/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml b/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml index 69914608b1e..1feeefd2259 100644 --- a/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml +++ b/automationtests/src/main/resources/ida/EkycOtp/EkycOtp.yml @@ -92,7 +92,7 @@ EkycOtp: auth_EkycOtp_Auth_With_Invalid_Future_Timestamp_UIN_Neg: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&requestTime=2052-05-19T06:29:44.809Z&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_Positive_EKYC_smoke_UIN$&isKyc=true&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident - checkErrorsOnlyInResponse: trues + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/EkycOtp/EkycOtp outputTemplate: ida/EkycOtp/EkycOtpResult diff --git a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml index d12f6b6b7be..89dbb1ede59 100644 --- a/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml +++ b/automationtests/src/main/resources/ida/MultiFactorAuth/MultiFactorAuth.yml @@ -1909,7 +1909,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_missing_bioSubType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident - checkErrorsOnlyInResponse: trues + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2084,7 +2084,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_UIN_invalid_bioType: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:AddIdentity_ValidParam_smoke_Pos_UIN$&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident - checkErrorsOnlyInResponse: trues + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2407,7 +2407,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_With_Finger_Invalid: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident - checkErrorsOnlyInResponse: trues + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error @@ -2497,7 +2497,7 @@ MultiFactorAuth: auth_MultiFactorAuth_Biometric_LeftIris_With_VID_invalid_Bio-Type_value_as_IR_instead_of_Iris: endPoint: /v1/identity/authenticate?moduleName=$MODULENAME$&certsDir=$CERTSDIR$&transactionId=$TRANSACTIONID$&id=$ID:GenerateVID_All_Valid_Smoke_Perpetual_sid_vid$&idType=VID&partnerUrlSuffix=$partnerKeyURL$&keyFileNameByPartnerName=true&partnerName=$PartnerName$ role: resident - checkErrorsOnlyInResponse: trues + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: ida/MultiFactorAuth/MultiFactorAuth outputTemplate: ida/MultiFactorAuth/error From e0e9dfd1c0c55e3428359b0d06e6f3492614fcba Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 21 Aug 2023 17:56:32 +0530 Subject: [PATCH 053/204] MOSIP-28922 --- .../src/main/resources/resident/AuthLock/createAuthLock.yml | 1 + .../main/resources/resident/AuthUnLock/createAuthUnLock.yml | 1 + .../GetCoordinateSpecificRegistrationCenters.yml | 6 +++--- .../GetRegistrationCenterWorkingDays.yml | 4 ++-- .../GetValidDocumentByLangCode.yml | 5 ++--- 5 files changed, 9 insertions(+), 8 deletions(-) diff --git a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml index e6861ac11a1..24f1ab652f5 100644 --- a/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml +++ b/automationtests/src/main/resources/resident/AuthLock/createAuthLock.yml @@ -1106,6 +1106,7 @@ AuthLock: Resident_AuthLock_Valid_UIN_Email_All: endPoint: /resident/v1/req/auth-lock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthLock/createAuthLock outputTemplate: resident/AuthLock/createAuthLockResult diff --git a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml index a0f974ab0d8..0647cdf5fa0 100644 --- a/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml +++ b/automationtests/src/main/resources/resident/AuthUnLock/createAuthUnLock.yml @@ -1586,6 +1586,7 @@ AuthUnlock: Resident_AuthUnLock_Valid_UIN_EmailChannel_Pos: endPoint: /resident/v1/req/auth-unlock role: resident + checkErrorsOnlyInResponse: true restMethod: post inputTemplate: resident/AuthUnLock/createAuthUnLock outputTemplate: resident/AuthUnLock/createAuthUnLockResult diff --git a/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml b/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml index 207d191c0a1..27d85b37b4f 100644 --- a/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml +++ b/automationtests/src/main/resources/resident/GetCoordinateSpecificRegistrationCenters/GetCoordinateSpecificRegistrationCenters.yml @@ -155,7 +155,7 @@ GetCoordinateSpecificRegistrationCenters: output: '{ "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "RES-SER-418", "message": "$IGNORE$" } ] @@ -176,7 +176,7 @@ GetCoordinateSpecificRegistrationCenters: output: '{ "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "RES-SER-418", "message": "$IGNORE$" } ] @@ -198,7 +198,7 @@ GetCoordinateSpecificRegistrationCenters: output: '{ "errors": [ { - "errorCode": "$IGNORE$", + "errorCode": "RES-SER-418", "message": "$IGNORE$" } ] diff --git a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml index 92e96de501d..0d3b1051c20 100644 --- a/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml +++ b/automationtests/src/main/resources/resident/GetRegistrationCenterWorkingDays/GetRegistrationCenterWorkingDays.yml @@ -78,8 +78,8 @@ GetRegistrationCenterWorkingDays: inputTemplate: resident/GetRegistrationCenterWorkingDays/getRegistrationCenterWorkingDays outputTemplate: resident/error input: '{ - "langCode": "eng", - "registrationCenterID": "" + "langCode": "eng", + "registrationCenterID": "" }' output: "404" diff --git a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml index 489dae1b351..fddb43ab5af 100644 --- a/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml +++ b/automationtests/src/main/resources/resident/GetValidDocumentByLangCode/GetValidDocumentByLangCode.yml @@ -38,6 +38,7 @@ GetValidDocumentByLangCode: Resident_GetValidDocumentByLangCode_Valid_Smoke: endPoint: /resident/v1/proxy/masterdata/validdocuments/{langCode} role: resident + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCode outputTemplate: resident/GetValidDocumentByLangCode/getValidDocumentByLangCodeResult @@ -45,9 +46,7 @@ GetValidDocumentByLangCode: "langCode": "$1STLANG$" }' output: '{ - "response": [{ - - }] + }' Resident_GetValidDocumentByLangCode_StatusCode_Empty_Invalid_Neg: From 2eff05194b42b77a9be5261ecea450f7247a76c0 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Mon, 21 Aug 2023 19:46:22 +0530 Subject: [PATCH 054/204] MOSIP-29045 --- .../apirig/admin/fw/util/AdminTestUtil.java | 23 +++++++++++++------ .../fw/util/OutputValidationUtil.java | 9 ++++++++ .../apirig/kernel/util/CommonLibrary.java | 8 +++++++ .../apirig/testrunner/HealthChecker.java | 9 ++++++++ .../apirig/testrunner/MosipTestRunner.java | 3 +++ .../apirig/testscripts/AddIdentity.java | 11 +++++++++ .../apirig/testscripts/AuditValidator.java | 11 +++++++++ .../testrig/apirig/testscripts/BioAuth.java | 11 +++++---- .../apirig/testscripts/BioAuthOld.java | 12 ++++++---- .../testscripts/BookAppoinmentByPrid.java | 11 +++++++++ .../apirig/testscripts/CreatePreReg.java | 11 +++++++++ .../apirig/testscripts/DBValidator.java | 12 ++++++++++ .../apirig/testscripts/DeleteWithParam.java | 11 +++++++++ .../testrig/apirig/testscripts/DemoAuth.java | 9 ++++++-- .../DemoAuthSimplePostForAutoGenId.java | 10 ++++++++ .../apirig/testscripts/EsignetBioAuth.java | 9 +++++--- .../apirig/testscripts/GetWithParam.java | 11 +++++++++ .../testscripts/GetWithParamForAutoGenId.java | 11 +++++++++ .../GetWithParamForAutoGenIdForKeyCloak.java | 11 +++++++++ .../GetWithParamForDownloadCard.java | 11 +++++++++ .../GetWithParamWithOtpGenerate.java | 11 +++++++++ .../apirig/testscripts/GetWithQueryParam.java | 10 ++++++++ .../GetWithQueryParamForDownloadCard.java | 12 ++++++++++ .../testrig/apirig/testscripts/KycAuth.java | 9 +++++--- .../apirig/testscripts/MassUINGenerator.java | 12 ++++++++++ .../apirig/testscripts/MultiFactorAuth.java | 10 +++++--- .../testscripts/MultiFactorAuthNew.java | 8 +++++-- .../testrig/apirig/testscripts/OtpAuth.java | 10 +++++--- .../apirig/testscripts/OtpAuthNew.java | 11 ++++++++- .../PatchWithBodyWithOtpGenerate.java | 12 ++++++++++ .../testscripts/PatchWithPathParam.java | 12 ++++++++++ .../PatchWithPathParamsAndBody.java | 12 ++++++++++ .../testscripts/PatchWithQueryParam.java | 11 +++++++++ .../PostWithAutogenIdWithOtpGenerate.java | 10 ++++++++ ...ostWithAutogenIdWithOtpGenerateForWla.java | 10 ++++++++ .../PostWithBodyAndPathParams.java | 12 ++++++++++ ...ostWithBodyAndQueryParamsForAutoGenId.java | 10 ++++++++ .../PostWithBodyWithOtpGenerate.java | 11 +++++++++ ...WithBodyWithOtpGenerateAndPdfDownload.java | 12 ++++++++++ .../PostWithBodyWithPdfDownload.java | 12 ++++++++++ .../testscripts/PostWithFormDataAndFile.java | 12 ++++++++++ ...WithFormDataAndFileForNotificationAPI.java | 12 ++++++++++ .../PostWithFormDataAndMultipleFile.java | 12 ++++++++++ .../PostWithFormPathParamAndFile.java | 12 ++++++++++ .../testscripts/PostWithOnlyPathParam.java | 12 ++++++++++ .../testscripts/PostWithParamAndFile.java | 12 ++++++++++ .../PostWithPathParamsAndBody.java | 11 +++++++++ .../PostWithPathParamsAndBodyForKeyCloak.java | 11 +++++++++ .../apirig/testscripts/PutWithPathParam.java | 11 +++++++++ .../testscripts/PutWithPathParamsAndBody.java | 11 +++++++++ .../apirig/testscripts/SimpleDelete.java | 10 ++++++++ .../apirig/testscripts/SimplePatch.java | 11 +++++++++ .../testscripts/SimplePatchForAutoGenId.java | 12 ++++++++++ .../apirig/testscripts/SimplePost.java | 11 +++++++++ .../testscripts/SimplePostForAutoGenId.java | 10 ++++++++ .../SimplePostForAutoGenIdForUrlEncoded.java | 10 ++++++++ .../SimplePostForDeRegisterDevice.java | 11 +++++++++ .../SimplePostForRegisteredDevice.java | 11 +++++++++ .../testrig/apirig/testscripts/SimplePut.java | 11 +++++++++ .../apirig/testscripts/UpdateDraft.java | 11 +++++++++ .../apirig/testscripts/UpdateIdentity.java | 11 +++++++++ .../apirig/testscripts/UpdatePrereg.java | 12 ++++++++++ 62 files changed, 645 insertions(+), 33 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index e2ea0a34c55..61f71e97e35 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -56,6 +56,7 @@ import org.apache.commons.io.FileUtils; import org.apache.commons.lang3.StringUtils; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.bouncycastle.operator.OperatorCreationException; import org.bouncycastle.util.io.pem.PemObject; @@ -297,6 +298,13 @@ private static void settriggerESignetKeyGen8(boolean value) { private static boolean gettriggerESignetKeyGen8() { return triggerESignetKeyGen8; } + + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * This method will hit post request and return the response @@ -569,19 +577,19 @@ public static void getFileNameToWrite(Response response, String testCaseName) { if (testCaseName.contains("Wla_uin_")) { fileName = bindingCertFile; } - if (testCaseName.contains("Wla_vid_")) { + else if (testCaseName.contains("Wla_vid_")) { fileName = bindingCertFileVid; } - if (testCaseName.contains("_Consentuin_")) { + else if (testCaseName.contains("_Consentuin_")) { fileName = bindingCertConsentFile; } - if (testCaseName.contains("_ConsentVid_")) { + else if (testCaseName.contains("_ConsentVid_")) { fileName = bindingCertConsentVidFile; } - if (testCaseName.contains("_Consent_SameClaim_uin_")) { + else if (testCaseName.contains("_Consent_SameClaim_uin_")) { fileName = bindingCertConsentSameClaimFile; } - if (testCaseName.contains("_Consent_SameClaim_Vid_")) { + else if (testCaseName.contains("_Consent_SameClaim_Vid_")) { fileName = bindingCertConsentVidSameClaimFile; } @@ -2542,12 +2550,13 @@ public String getJsonFromTemplate(String input, String template) { return getJsonFromTemplate(input, template, true); } + + public static Handlebars handlebars = new Handlebars(); + public static Gson gson = new Gson(); public String getJsonFromTemplate(String input, String template, boolean readFile) { String resultJson = null; try { - Handlebars handlebars = new Handlebars(); - Gson gson = new Gson(); Type type = new TypeToken>() { }.getType(); // logger.info(input); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java index 5278bcde8ed..970dbaff69d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/OutputValidationUtil.java @@ -12,6 +12,7 @@ import java.util.Map.Entry; import java.util.regex.Pattern; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONArray; import org.json.JSONException; @@ -28,6 +29,7 @@ import io.mosip.testrig.apirig.authentication.fw.precon.JsonPrecondtion; import io.mosip.testrig.apirig.authentication.fw.precon.MessagePrecondtion; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; /** * Perform output validation between expected and actual json file or message @@ -39,6 +41,13 @@ public class OutputValidationUtil extends AuthTestsUtil{ private static final Logger OUTPUTVALIDATION_LOGGER = Logger.getLogger(OutputValidationUtil.class); + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + OUTPUTVALIDATION_LOGGER.setLevel(Level.ALL); + else + OUTPUTVALIDATION_LOGGER.setLevel(Level.ERROR); + } + /** * The method will perform output validation by comparing expected and actual value * diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java index 69af82ab56a..5cdae236dc4 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/CommonLibrary.java @@ -23,6 +23,7 @@ import java.util.Properties; import java.util.stream.Collectors; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONException; import org.json.simple.JSONArray; @@ -51,6 +52,13 @@ public class CommonLibrary extends BaseTestCase { private static Logger logger = Logger.getLogger(CommonLibrary.class); private ApplicationLibrary applicationLibrary = new ApplicationLibrary(); + + public CommonLibrary() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } public void checkResponseUTCTime(Response response) { logger.info(response.asString()); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java index dbb1be379d6..7ce5f335c56 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/HealthChecker.java @@ -11,6 +11,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; @@ -22,6 +23,14 @@ import io.restassured.response.Response; public class HealthChecker implements Runnable { + + public HealthChecker() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + private static final Logger logger = Logger.getLogger(HealthChecker.class); public static boolean bTerminate = false; public static String propsHealthCheckURL = MosipTestRunner.getResourcePath() + "/" diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 70a5554471c..42068307a26 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -25,6 +25,7 @@ import io.mosip.testrig.apirig.admin.fw.util.AdminTestUtil; import io.mosip.testrig.apirig.admin.fw.util.EncryptionDecrptionUtil; +import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.dbaccess.DBManager; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.ida.certificate.CertificateGenerationUtil; @@ -71,6 +72,8 @@ public static void main(String[] arg) { // setLogLevelForAllClasses(Level.ERROR); // Logger.getRootLogger().setLevel(Level.ERROR); BaseTestCase.suiteSetup(); + AdminTestUtil.setLogLevel(); + OutputValidationUtil.setLogLevel(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); // For now we are not doing health check for qa-115. diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java index ca0c6f7e747..f2d8fdcb3ec 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AddIdentity.java @@ -11,6 +11,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -19,6 +20,7 @@ import org.testng.SkipException; import org.testng.annotations.AfterClass; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -33,6 +35,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.authentication.fw.util.RestClient; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KernelAuthentication; import io.mosip.testrig.apirig.kernel.util.KeycloakUserManager; import io.mosip.testrig.apirig.service.BaseTestCase; @@ -52,6 +55,14 @@ public String getTestName() { return testCaseName; } + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * Data provider class provides test case list diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AuditValidator.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AuditValidator.java index a6e6dc2eac3..40f53d27655 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AuditValidator.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/AuditValidator.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -27,6 +29,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.dbaccess.AuditDBManager; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -44,6 +47,14 @@ public String getTestName() { return testCaseName; } + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * Data provider class provides test case list * diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java index 8a35e6ec506..5ab78e280f7 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuth.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONException; import org.json.JSONObject; @@ -40,11 +41,13 @@ public class BioAuth extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; public boolean isInternal = false; - + @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); - + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java index 693525a6f10..71308506d93 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BioAuthOld.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONException; import org.json.JSONObject; @@ -30,6 +31,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -40,11 +42,11 @@ public class BioAuthOld extends AdminTestUtil implements ITest { public boolean isInternal = false; @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); - - - AuthPartnerProcessor.startProcess(); + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java index 5c995fd3e1d..4951b65759b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/BookAppoinmentByPrid.java @@ -6,6 +6,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.Assert; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -27,6 +29,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.authentication.fw.util.RestClient; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KernelAuthentication; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -36,6 +39,14 @@ public class BookAppoinmentByPrid extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java index b9ef3257d6e..66f8224669a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/CreatePreReg.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -26,6 +28,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -35,6 +38,14 @@ public class CreatePreReg extends AdminTestUtil implements ITest { protected String testCaseName = ""; public String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DBValidator.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DBValidator.java index 50c49791003..65c62221237 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DBValidator.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DBValidator.java @@ -8,6 +8,7 @@ import java.util.Set; import java.util.TreeSet; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -16,6 +17,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -29,6 +31,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.dbaccess.AuditDBManager; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -37,6 +40,15 @@ public class DBValidator extends AdminTestUtil implements ITest { protected String testCaseName = ""; public static List templateFields = new ArrayList<>(); public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java index daaae224cf5..89236ba7c1e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DeleteWithParam.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -34,6 +37,14 @@ public class DeleteWithParam extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java index d97cb32fcc9..c092905ce82 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuth.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -31,6 +32,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.ida.certificate.PartnerRegistration; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -41,8 +43,11 @@ public class DemoAuth extends AdminTestUtil implements ITest { public boolean isInternal = false; @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java index cb2529be54d..2ae80b6c8b3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/DemoAuthSimplePostForAutoGenId.java @@ -9,6 +9,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -17,6 +18,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -40,6 +42,14 @@ public class DemoAuthSimplePostForAutoGenId extends AdminTestUtil implements ITe protected String testCaseName = ""; public String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java index 9e8e5d2cc03..195e99f7c54 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/EsignetBioAuth.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONArray; import org.json.JSONObject; @@ -41,9 +42,11 @@ public class EsignetBioAuth extends AdminTestUtil implements ITest { public boolean isInternal = false; @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); - + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java index 390cd4c68ef..f8f76f39f48 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -38,6 +40,15 @@ public class GetWithParam extends AdminTestUtil implements ITest { public Response response = null; public boolean sendEsignetToken = false; public boolean auditLogCheck = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java index 3fd3d0ecee0..a0b9477e1e9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -26,6 +28,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -36,6 +39,14 @@ public class GetWithParamForAutoGenId extends AdminTestUtil implements ITest { public Response response = null; public boolean sendEsignetToken = false; public boolean auditLogCheck = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java index 581f1558a13..946c65c5eda 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenIdForKeyCloak.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -23,6 +25,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -32,6 +35,14 @@ public class GetWithParamForAutoGenIdForKeyCloak extends AdminTestUtil implement public String idKeyName = null; public String valueKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java index 445d71d5eea..3d7b15999ca 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForDownloadCard.java @@ -4,6 +4,7 @@ import java.io.IOException; import java.lang.reflect.Field; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -23,6 +25,7 @@ import io.mosip.testrig.apirig.admin.fw.util.AdminTestUtil; import io.mosip.testrig.apirig.admin.fw.util.TestCaseDTO; import io.mosip.testrig.apirig.global.utils.GlobalMethods; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -35,6 +38,14 @@ public class GetWithParamForDownloadCard extends AdminTestUtil implements ITest public boolean sendEsignetToken = false; public boolean auditLogCheck = false; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java index df06e12d9f0..5c4c85ab278 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamWithOtpGenerate.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -27,6 +29,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -35,6 +38,14 @@ public class GetWithParamWithOtpGenerate extends AdminTestUtil implements ITest private static final Logger logger = Logger.getLogger(GetWithParamWithOtpGenerate.class); protected String testCaseName = ""; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java index 7e3d3909953..252a173ab7a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -36,6 +38,14 @@ public class GetWithQueryParam extends AdminTestUtil implements ITest { private static final Logger logger = Logger.getLogger(GetWithQueryParam.class); protected String testCaseName = ""; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java index 1438193088b..a4e743a9814 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParamForDownloadCard.java @@ -5,6 +5,7 @@ import java.lang.reflect.Field; import java.util.ArrayList; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.admin.fw.util.TestCaseDTO; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.global.utils.GlobalMethods; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -35,6 +38,15 @@ public class GetWithQueryParamForDownloadCard extends AdminTestUtil implements I public byte[] pdf=null; public String pdfAsText =null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java index bd4540595cd..450782e2509 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/KycAuth.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -39,9 +40,11 @@ public class KycAuth extends AdminTestUtil implements ITest { public boolean isInternal = false; @BeforeClass - public static void setPrerequiste() { - return; - + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java index fdbbc0394c6..5034136b6b4 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MassUINGenerator.java @@ -10,6 +10,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -17,6 +18,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -33,6 +35,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.authentication.fw.util.RestClient; import io.mosip.testrig.apirig.authentication.fw.util.RunConfigUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KernelAuthentication; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -43,6 +46,15 @@ public class MassUINGenerator extends AdminTestUtil implements ITest { private Map storeUinData = new HashMap<>(); private Map storeRidData = new HashMap<>(); private static long perTCUinCount; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java index b8d7322f67a..43430b38b1f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuth.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -30,6 +31,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -39,9 +41,11 @@ public class MultiFactorAuth extends AdminTestUtil implements ITest { public Response response = null; @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); - AuthPartnerProcessor.startProcess(); + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java index 6dcacbf7be7..ba687108cdc 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/MultiFactorAuthNew.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -40,8 +41,11 @@ public class MultiFactorAuthNew extends AdminTestUtil implements ITest { public Response response = null; @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java index 579053016a9..6ca0a3dd17c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuth.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONException; import org.json.JSONObject; @@ -31,6 +32,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -41,9 +43,11 @@ public class OtpAuth extends AdminTestUtil implements ITest { public boolean isInternal = false; @BeforeClass - public static void setPrerequiste() { - logger.info("Starting authpartner demo service..."); - AuthPartnerProcessor.startProcess(); + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); } /** diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java index fc82c0904fd..e95d53c098b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/OtpAuthNew.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONException; import org.json.JSONObject; @@ -17,6 +18,7 @@ import org.testng.SkipException; import org.testng.annotations.AfterClass; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -41,7 +43,14 @@ public class OtpAuthNew extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; public boolean isInternal = false; - + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java index db8a92f3f58..281e3b90ff3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithBodyWithOtpGenerate.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -12,6 +13,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,12 +27,22 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; public class PatchWithBodyWithOtpGenerate extends AdminTestUtil implements ITest { private static final Logger logger = Logger.getLogger(PatchWithBodyWithOtpGenerate.class); protected String testCaseName = ""; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java index d0cd97c1ada..19ed3a2eb0e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParam.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -32,6 +35,15 @@ public class PatchWithPathParam extends AdminTestUtil implements ITest { private static final Logger logger = Logger.getLogger(PatchWithPathParam.class); protected String testCaseName = ""; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java index 5785fee9f2c..46305571d81 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithPathParamsAndBody.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -24,6 +26,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -33,6 +36,15 @@ public class PatchWithPathParamsAndBody extends AdminTestUtil implements ITest { protected String testCaseName = ""; String pathParams = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java index 82ed1a05c92..80830ba19d5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PatchWithQueryParam.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -32,6 +35,14 @@ public class PatchWithQueryParam extends AdminTestUtil implements ITest { private static final Logger logger = Logger.getLogger(PatchWithQueryParam.class); protected String testCaseName = ""; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java index d4fd6c1bd5a..fc272aa66c9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerate.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.SkipException; import org.testng.annotations.AfterClass; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -37,6 +39,14 @@ public class PostWithAutogenIdWithOtpGenerate extends AdminTestUtil implements I public String idKeyName = null; public Response response = null; public boolean auditLogCheck = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java index 8ce0328ddcd..b74e13e868c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithAutogenIdWithOtpGenerateForWla.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.SkipException; import org.testng.annotations.AfterClass; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -36,6 +38,14 @@ public class PostWithAutogenIdWithOtpGenerateForWla extends AdminTestUtil implem public String idKeyName = null; public Response response = null; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java index 92724e3c7f9..5bff76b706f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndPathParams.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -26,6 +28,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -36,6 +39,15 @@ public class PostWithBodyAndPathParams extends AdminTestUtil implements ITest { String pathParams = null; String headers = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java index 5aebe655d09..3d13d5114ff 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyAndQueryParamsForAutoGenId.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -35,6 +37,14 @@ public class PostWithBodyAndQueryParamsForAutoGenId extends AdminTestUtil implem public String idKeyName = null; public Response response = null; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + @Override public String getTestName() { return testCaseName; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java index e66ccfd396b..62e7c2c3105 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerate.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -12,6 +13,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -35,6 +37,15 @@ public class PostWithBodyWithOtpGenerate extends AdminTestUtil implements ITest public Response response = null; public boolean sendEsignetToken = false; public boolean auditLogCheck = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java index fc7eb23a0d1..e855bb64852 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithOtpGenerateAndPdfDownload.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -31,6 +33,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.global.utils.GlobalMethods; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -40,6 +43,15 @@ public class PostWithBodyWithOtpGenerateAndPdfDownload extends AdminTestUtil imp public Response response = null; public byte[] pdf=null; public String pdfAsText =null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java index 8d4fbbff36a..1e8dc198bce 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithBodyWithPdfDownload.java @@ -4,6 +4,7 @@ import java.io.IOException; import java.lang.reflect.Field; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -24,6 +26,7 @@ import io.mosip.testrig.apirig.admin.fw.util.TestCaseDTO; import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.global.utils.GlobalMethods; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -34,6 +37,15 @@ public class PostWithBodyWithPdfDownload extends AdminTestUtil implements ITest public byte[] pdf=null; public String pdfAsText =null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java index 8996c197b0c..ef7515c4f2b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFile.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -23,6 +25,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -31,6 +34,15 @@ public class PostWithFormDataAndFile extends AdminTestUtil implements ITest { protected String testCaseName = ""; String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java index 8dd149e4063..437c4299208 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndFileForNotificationAPI.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -24,6 +26,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -33,6 +36,15 @@ public class PostWithFormDataAndFileForNotificationAPI extends AdminTestUtil imp protected String testCaseName = ""; String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java index b9c96b941fd..5a1920cbe66 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormDataAndMultipleFile.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -23,6 +25,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -31,6 +34,15 @@ public class PostWithFormDataAndMultipleFile extends AdminTestUtil implements IT protected String testCaseName = ""; String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java index 63715a2dbe2..fefc38cf79f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -12,6 +13,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -24,6 +26,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -32,6 +35,15 @@ public class PostWithFormPathParamAndFile extends AdminTestUtil implements ITest protected String testCaseName = ""; public String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java index c743eccba02..668fb1fea45 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -26,6 +28,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -34,6 +37,15 @@ public class PostWithOnlyPathParam extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java index 3350ba4c615..6a3cb506eee 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -34,6 +37,15 @@ public class PostWithParamAndFile extends AdminTestUtil implements ITest { public String idKeyName = null; public Response response = null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java index 76991ab1673..0c6f6f62704 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBody.java @@ -6,6 +6,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.Assert; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -27,6 +29,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.authentication.fw.util.RestClient; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KernelAuthentication; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -36,6 +39,14 @@ public class PostWithPathParamsAndBody extends AdminTestUtil implements ITest { protected String testCaseName = ""; public String pathParams = null; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java index 37e3f5deaa5..e80200d8b02 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithPathParamsAndBodyForKeyCloak.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -11,6 +12,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -23,6 +25,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -31,6 +34,14 @@ public class PostWithPathParamsAndBodyForKeyCloak extends AdminTestUtil implemen protected String testCaseName = ""; public String pathParams = null; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java index 29e83c97974..28de6167298 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParam.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -32,6 +35,14 @@ public class PutWithPathParam extends AdminTestUtil implements ITest { private static final Logger logger = Logger.getLogger(PutWithPathParam.class); protected String testCaseName = ""; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java index 40527a954a9..5e9cb6faf70 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PutWithPathParamsAndBody.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -37,6 +39,15 @@ public class PutWithPathParamsAndBody extends AdminTestUtil implements ITest { protected String testCaseName = ""; String pathParams = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java index 2eccd10a586..593a688ac9f 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -35,6 +37,14 @@ public class SimpleDelete extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + @Override public String getTestName() { return testCaseName; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java index 665e5d05915..7dbb32c1f36 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatch.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -26,6 +28,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -34,6 +37,14 @@ public class SimplePatch extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java index 1b8f53a57a3..37f8366f68d 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePatchForAutoGenId.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -33,6 +36,15 @@ public class SimplePatchForAutoGenId extends AdminTestUtil implements ITest { protected String testCaseName = ""; String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java index 9c7a8958d39..aaf87f82866 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -36,6 +38,15 @@ public class SimplePost extends AdminTestUtil implements ITest { public Response response = null; public boolean sendEsignetToken = false; public boolean auditLogCheck = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java index d0ff6f9128b..04eb94c6e90 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenId.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -15,6 +16,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -39,6 +41,14 @@ public class SimplePostForAutoGenId extends AdminTestUtil implements ITest { public Response response = null; public boolean sendEsignetToken = false; public boolean auditLogCheck = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java index b45269ab97f..46bd7266fb1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForAutoGenIdForUrlEncoded.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -35,6 +37,14 @@ public class SimplePostForAutoGenIdForUrlEncoded extends AdminTestUtil implement protected String testCaseName = ""; public String idKeyName = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java index 28886910586..cf5343923c5 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForDeRegisterDevice.java @@ -7,6 +7,7 @@ import java.util.Map; import org.apache.commons.codec.binary.Base64; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -15,6 +16,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -27,6 +29,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -36,6 +39,14 @@ public class SimplePostForDeRegisterDevice extends AdminTestUtil implements ITes Encoder encoder = java.util.Base64.getEncoder(); + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java index 2478f20c15e..90f178ca924 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePostForRegisteredDevice.java @@ -8,6 +8,7 @@ import java.util.Map; import java.util.TimeZone; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -16,6 +17,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -31,6 +33,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; import net.minidev.json.JSONArray; @@ -41,6 +44,14 @@ public class SimplePostForRegisteredDevice extends AdminTestUtil implements ITes Encoder encoder = Base64.getEncoder(); + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java index da81c5fc5e8..b0f3f62b8c3 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -14,6 +15,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -26,6 +28,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -35,6 +38,14 @@ public class SimplePut extends AdminTestUtil implements ITest { protected String testCaseName = ""; public Response response = null; public boolean sendEsignetToken = false; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java index 2f10cc5a74e..bae4c923787 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateDraft.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.testng.ITest; import org.testng.ITestContext; @@ -12,6 +13,7 @@ import org.testng.SkipException; import org.testng.annotations.AfterClass; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -24,6 +26,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -33,6 +36,14 @@ public class UpdateDraft extends AdminTestUtil implements ITest { protected String testCaseName = ""; String pathParams = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } /** * get current testcaseName diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java index 32b5e93c01e..8928e8182b0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdateIdentity.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.Assert; @@ -16,6 +17,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -30,6 +32,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.ida.certificate.PartnerRegistration; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -38,6 +41,14 @@ public class UpdateIdentity extends AdminTestUtil implements ITest { private static final Logger logger = Logger.getLogger(UpdateIdentity.class); protected String testCaseName = ""; private static String identity; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } public static void saveIdentityForUpdateIdentityVerification(String id) { identity = id; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java index 4b55b6c2651..cdbb7322ff0 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/UpdatePrereg.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; import org.testng.ITest; @@ -13,6 +14,7 @@ import org.testng.Reporter; import org.testng.SkipException; import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import org.testng.internal.BaseTestMethod; @@ -25,6 +27,7 @@ import io.mosip.testrig.apirig.authentication.fw.util.AuthenticationTestException; import io.mosip.testrig.apirig.authentication.fw.util.OutputValidationUtil; import io.mosip.testrig.apirig.authentication.fw.util.ReportUtil; +import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.service.BaseTestCase; import io.mosip.testrig.apirig.testrunner.HealthChecker; import io.restassured.response.Response; @@ -34,6 +37,15 @@ public class UpdatePrereg extends AdminTestUtil implements ITest { protected String testCaseName = ""; String pathParams = null; public Response response = null; + + @BeforeClass + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } + /** * get current testcaseName */ From 2140478f8f9e8409ea7090f7cb0934dfdb0b3584 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 22 Aug 2023 12:11:01 +0530 Subject: [PATCH 055/204] MOSIP-29045 --- .../mosip/testrig/apirig/testrunner/MockSMTPListener.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java index 74ea4aa0ca2..36f388a7b48 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MockSMTPListener.java @@ -13,6 +13,7 @@ import java.util.regex.Pattern; import org.apache.commons.lang3.StringUtils; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONException; @@ -31,6 +32,13 @@ public class MockSMTPListener { .synchronizedMap(new HashMap()); public static Boolean bTerminate = false; + + public MockSMTPListener() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); + } public void run() { try { From 2fbed6951136b591eca4f06e2df4dbf2cca53722 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 22 Aug 2023 12:14:37 +0530 Subject: [PATCH 056/204] MOSIP-29037 --- .../src/main/resources/config/valueMapping.properties | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/automationtests/src/main/resources/config/valueMapping.properties b/automationtests/src/main/resources/config/valueMapping.properties index 326e0c9b758..e3247b8ec2a 100644 --- a/automationtests/src/main/resources/config/valueMapping.properties +++ b/automationtests/src/main/resources/config/valueMapping.properties @@ -29,4 +29,5 @@ introducerName=TEST_INTRODUCERNAME bloodGroup=O Miss-TitleFromServer=MIS Mr-TitleFromServer=MIR -Mrs-TitleFromServer=MRS \ No newline at end of file +Mrs-TitleFromServer=MRS +Miss-TitleFromServer.=MIS \ No newline at end of file From 534bf23b1c8e76ed19a56c53d56b5f291401519c Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 22 Aug 2023 15:47:38 +0530 Subject: [PATCH 057/204] MOSIP-29045 --- .../CertificateGenerationUtil.java | 9 ++++---- .../KeyCloakUserAndAPIKeyGeneration.java | 8 +++++++ .../MispPartnerAndLicenseKeyGeneration.java | 8 +++++++ .../ida/certificate/PartnerRegistration.java | 8 +++++++ .../apirig/kernel/util/ConfigManager.java | 3 ++- .../testrig/apirig/service/BaseTestCase.java | 7 ++++++ .../apirig/testrunner/MosipTestRunner.java | 23 ++++++++----------- .../apirig/testscripts/GetWithParam.java | 1 - .../testscripts/GetWithParamForAutoGenId.java | 1 - .../apirig/testscripts/GetWithQueryParam.java | 1 - .../PostWithFormPathParamAndFile.java | 1 - .../testscripts/PostWithOnlyPathParam.java | 1 - .../testscripts/PostWithParamAndFile.java | 1 - .../apirig/testscripts/SimpleDelete.java | 1 - .../apirig/testscripts/SimplePost.java | 1 - .../testrig/apirig/testscripts/SimplePut.java | 1 - 16 files changed, 48 insertions(+), 27 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java index 383da6b2394..238b89f435b 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/CertificateGenerationUtil.java @@ -5,6 +5,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; @@ -19,6 +20,10 @@ public class CertificateGenerationUtil extends AdminTestUtil { private static final Logger lOGGER = Logger.getLogger(CertificateGenerationUtil.class); static { + if (ConfigManager.IsDebugEnabled()) + lOGGER.setLevel(Level.ALL); + else + lOGGER.setLevel(Level.ERROR); lOGGER.info("EncryptUtilBaseUrl " + ConfigManager.getAuthDemoServiceUrl()); getThumbprints(); } @@ -46,9 +51,7 @@ public static void getAndUploadIdaCertificate(String applicationId, String refer MediaType.APPLICATION_JSON, GlobalConstants.AUTHORIZATION, token); JSONObject responseJson = new JSONObject(response.asString()); JSONObject responseValue = (JSONObject) responseJson.get("response"); - lOGGER.info(responseValue); String idaCertValue = responseValue.getString("certificate"); - lOGGER.info(idaCertValue); JSONObject request = new JSONObject(); request.put("certData", idaCertValue); @@ -64,8 +67,6 @@ public static void getAndUploadIdaCertificate(String applicationId, String refer Response reponse = RestClient.postRequest(ConfigManager.getAuthDemoServiceUrl() + "/" + endPoint, request.toMap(), MediaType.APPLICATION_JSON, MediaType.TEXT_PLAIN); - lOGGER.info(reponse); - } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java index 3f812ed9781..115d10aba27 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/KeyCloakUserAndAPIKeyGeneration.java @@ -4,6 +4,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; @@ -24,6 +25,13 @@ public class KeyCloakUserAndAPIKeyGeneration extends AdminTestUtil { static String randomAbbreviation = generateRandomAlphabeticString(4).toUpperCase(); static String policyName = AdminTestUtil.policyName; + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + lOGGER.setLevel(Level.ALL); + else + lOGGER.setLevel(Level.ERROR); + } + public static String createKCUserAndGetAPIKey() { KeycloakUserManager.createKeyCloakUsers(partnerId, emailId, role); String mappingKey = submittingPartnerAndGetMappingKey(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java index 85199a7f19a..899c615b1d1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/MispPartnerAndLicenseKeyGeneration.java @@ -5,6 +5,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; @@ -27,6 +28,13 @@ public class MispPartnerAndLicenseKeyGeneration extends AdminTestUtil{ public static String mispPartnerType = "Misp_Partner"; static String getPartnerType = "MISP"; + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + lOGGER.setLevel(Level.ALL); + else + lOGGER.setLevel(Level.ERROR); + } + public static String getAndUploadCertificatesAndGenerateMispLicKey() { if (localHostUrl == null) { localHostUrl = getLocalHostUrl(); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java index ad1cc4c02fc..e6c38575950 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/ida/certificate/PartnerRegistration.java @@ -6,6 +6,7 @@ import javax.ws.rs.core.MediaType; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.json.JSONObject; @@ -34,6 +35,13 @@ public class PartnerRegistration extends AdminTestUtil { public static String partnerType = "AUTH_PARTNER"; static String getPartnerType = "RELYING_PARTY"; public static String policyGroup = AdminTestUtil.policyGroup; + + public static void setLogLevel() { + if (ConfigManager.IsDebugEnabled()) + lOGGER.setLevel(Level.ALL); + else + lOGGER.setLevel(Level.ERROR); + } public static String generateAndGetPartnerKeyUrl() { if (!BaseTestCase.isTargetEnvLTS()) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java index 18f71abbcca..096d8bdf2f9 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/kernel/util/ConfigManager.java @@ -390,7 +390,8 @@ public static void init() { public static boolean isInTobeSkippedList(String stringToFind) { synchronized (toSkippedList) { List toBeSkippedLsit = Arrays.asList(toSkippedList.split(",")); - LOGGER.info("toSkippedList: " + toSkippedList + ", toBeSkippedLsit : "+ toBeSkippedLsit + ", stringToFind : "+ stringToFind ); + if (ConfigManager.IsDebugEnabled()) + LOGGER.info("toSkippedList: " + toSkippedList + ", toBeSkippedLsit : "+ toBeSkippedLsit + ", stringToFind : "+ stringToFind ); for (String string : toBeSkippedLsit) { if (string.equalsIgnoreCase(stringToFind)) return true; diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java index 42e583af392..5a677298eae 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/service/BaseTestCase.java @@ -15,6 +15,7 @@ import javax.ws.rs.core.MediaType; import org.apache.commons.io.FileUtils; +import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.apache.log4j.PropertyConfigurator; import org.json.JSONArray; @@ -214,9 +215,15 @@ public static void initialize() { logger.info("Configs from properties file are set."); } + + public static void suiteSetup() { + if (ConfigManager.IsDebugEnabled()) + logger.setLevel(Level.ALL); + else + logger.setLevel(Level.ERROR); File logFile = new File("./src/logs/mosip-api-test.log"); if (logFile.exists()) try { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java index 42068307a26..9579cbcce41 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testrunner/MosipTestRunner.java @@ -29,6 +29,8 @@ import io.mosip.testrig.apirig.dbaccess.DBManager; import io.mosip.testrig.apirig.global.utils.GlobalConstants; import io.mosip.testrig.apirig.ida.certificate.CertificateGenerationUtil; +import io.mosip.testrig.apirig.ida.certificate.KeyCloakUserAndAPIKeyGeneration; +import io.mosip.testrig.apirig.ida.certificate.MispPartnerAndLicenseKeyGeneration; import io.mosip.testrig.apirig.ida.certificate.PartnerRegistration; import io.mosip.testrig.apirig.kernel.util.ConfigManager; import io.mosip.testrig.apirig.kernel.util.KeycloakUserManager; @@ -68,12 +70,8 @@ public static void main(String[] arg) { ExtractResource.extractResourceFromJar(); } ConfigManager.init(); -// configureLog4j(); -// setLogLevelForAllClasses(Level.ERROR); -// Logger.getRootLogger().setLevel(Level.ERROR); BaseTestCase.suiteSetup(); - AdminTestUtil.setLogLevel(); - OutputValidationUtil.setLogLevel(); + setLogLevels(); AdminTestUtil.encryptDecryptUtil = new EncryptionDecrptionUtil(); // For now we are not doing health check for qa-115. @@ -145,14 +143,13 @@ public static void main(String[] arg) { } - private static void configureLog4j() { - // Configure log4j programmatically (you can also use a properties file) - PropertyConfigurator.configure(MosipTestRunner.getResourcePath() + "/" + "log4j.properties"); - } - private static void setLogLevelForAllClasses(Level level) { - Logger rootLogger = Logger.getRootLogger(); - rootLogger.setLevel(level); - } + private static void setLogLevels(){ + AdminTestUtil.setLogLevel(); + OutputValidationUtil.setLogLevel(); + PartnerRegistration.setLogLevel(); + KeyCloakUserAndAPIKeyGeneration.setLogLevel(); + MispPartnerAndLicenseKeyGeneration.setLogLevel(); + } /** * The method to start mosip testng execution diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java index f8f76f39f48..6154d776864 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParam.java @@ -144,7 +144,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java index a0b9477e1e9..0a2e5d2d322 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithParamForAutoGenId.java @@ -124,7 +124,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java index 252a173ab7a..5cf93d6dbb2 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/GetWithQueryParam.java @@ -129,7 +129,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) throw new AdminTestException("Failed at output validation"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java index fefc38cf79f..23223ab163c 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithFormPathParamAndFile.java @@ -99,7 +99,6 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java index 668fb1fea45..e52bf13da00 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithOnlyPathParam.java @@ -116,7 +116,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java index 6a3cb506eee..1742831d195 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/PostWithParamAndFile.java @@ -103,7 +103,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java index 593a688ac9f..16851cf1251 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimpleDelete.java @@ -122,7 +122,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java index aaf87f82866..dae38f44b31 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePost.java @@ -144,7 +144,6 @@ public void test(TestCaseDTO testCaseDTO) throws AuthenticationTestException, Ad response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java index b0f3f62b8c3..65a7b5c979a 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/testscripts/SimplePut.java @@ -124,7 +124,6 @@ public void test(TestCaseDTO testCaseDTO) throws AdminTestException { response.asString(), getJsonFromTemplate(testCaseDTO.getOutput(), testCaseDTO.getOutputTemplate()), testCaseDTO.isCheckErrorsOnlyInResponse()); } - logger.info(ouputValid); Reporter.log(ReportUtil.getOutputValidationReport(ouputValid)); if (!OutputValidationUtil.publishOutputResult(ouputValid)) From f510e860ed1fae1ac263088673f17057605ef0f1 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Tue, 22 Aug 2023 19:07:04 +0530 Subject: [PATCH 058/204] MOSIP-28924 --- .../ida/UpdateIdentity/UpdateIdentity.yml | 1 + .../UpdateIdentity/updateIdentityResult.hbs | 10 ++--- .../masterdata/BulkUpload/BulkUpload.yml | 1 - .../BulkUpload/bulkUploadResult.hbs | 4 +- .../masterdata/Device/UpdateDevice.yml | 4 +- .../masterdata/Device/createDeviceResult.hbs | 44 +++++++++---------- .../deviceSpecFilterResult.hbs | 6 +-- .../DocumentType/CreateDocumentType.yml | 4 +- .../DocumentType/UpdateDocumentType.yml | 2 +- .../DocumentType/documentTypeResult.hbs | 4 +- .../FetchAllDeviceTypes.yml | 4 +- .../fetchAllDeviceTypesResult.hbs | 2 +- .../FetchAllMachineSpecification.yml | 5 +-- .../masterdata/FetchMachine/FetchMachine.yml | 4 +- .../fetchMachineByCenterResult.hbs | 2 +- .../MachineTypeSearch/MachineTypeSearch.yml | 4 +- .../machineTypeSearchResult.hbs | 10 ++--- .../searchBlockListedWordsResult.hbs | 10 ++--- .../SearchMachineSpec/SearchMachineSpec.yml | 26 ++++++++--- .../searchMachineSpecResult.hbs | 9 ++-- 20 files changed, 84 insertions(+), 72 deletions(-) diff --git a/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml b/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml index 69ec50b9811..c4cb5d63595 100644 --- a/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml +++ b/automationtests/src/main/resources/ida/UpdateIdentity/UpdateIdentity.yml @@ -2,6 +2,7 @@ UpdateIdentity: Auth_UpdateIdentity_updatePhone_withValidParameters_smoke_Pos_smoke: endPoint: /idrepository/v1/identity/ role: idrepo + checkErrorsOnlyInResponse: true restMethod: patch inputTemplate: ida/UpdateIdentity/updateIdentity outputTemplate: ida/UpdateIdentity/updateIdentityResult diff --git a/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentityResult.hbs b/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentityResult.hbs index 4ebe34ae861..2d09ee5461c 100644 --- a/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentityResult.hbs +++ b/automationtests/src/main/resources/ida/UpdateIdentity/updateIdentityResult.hbs @@ -1,12 +1,12 @@ { - "id": "mosip.id.update", - "version": "v1", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}", - "identity": null, - "documents": null + "identity": "$IGNORE$", + "documents": "$IGNORE$" }, "errors": [] } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml b/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml index dca3b9033b5..59f64be4bad 100644 --- a/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml +++ b/automationtests/src/main/resources/masterdata/BulkUpload/BulkUpload.yml @@ -12,7 +12,6 @@ BulkUpload: "tableName":"gender" }' output: '{ - "transcationId": "$IGNORE$", "tableName": "gender", "operation": "insert" }' diff --git a/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs b/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs index 3a9150fe282..531a869abef 100644 --- a/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs +++ b/automationtests/src/main/resources/masterdata/BulkUpload/bulkUploadResult.hbs @@ -7,8 +7,8 @@ "transcationId": "$IGNORE$", "tableName": "{{tableName}}", "operation": "{{operation}}", - "successCount": $IGNORE$, - "category": "masterData", + "successCount": "$IGNORE$", + "category": "$IGNORE$", "status": "$IGNORE$", "statusDescription": "$IGNORE$", "uploadedBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml b/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml index 2df903248bd..b454a3760f1 100644 --- a/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml +++ b/automationtests/src/main/resources/masterdata/Device/UpdateDevice.yml @@ -23,7 +23,7 @@ UpdateDevice: "name": "$IGNORE$", "deviceSpecId": "743", "ipAddress": "172.23.174.113", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", "zoneCode": "CST", @@ -55,7 +55,7 @@ UpdateDevice: "name": "$IGNORE$", "deviceSpecId": "736", "ipAddress": "172.23.174.113", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "langCode": "eng", "macAddress": "D4-3D-7E-C0-8C-4A", "zoneCode": "CST", diff --git a/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs b/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs index 981d938d769..4505eb25e22 100644 --- a/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/Device/createDeviceResult.hbs @@ -1,25 +1,25 @@ { -"id":"$IGNORE$", -"version":"$IGNORE$", -"responsetime":"$IGNORE$", -"metadata":"$IGNORE$", -"response":{ -"id":"$IGNORE$", -"name":"{{name}}", -"serialNum":"{{serialNum}}", -"deviceSpecId":"{{deviceSpecId}}", -"macAddress":"{{macAddress}}", -"ipAddress":"{{ipAddress}}", -"langCode":"{{langCode}}", -"validityDateTime":"{{validityDateTime}}", -"isActive":{{isActive}}, -"createdBy":"$IGNORE$", -"createdDateTime":"$IGNORE$", -"updatedBy":"$IGNORE$", -"updatedDateTime":"$IGNORE$", -"isDeleted":"$IGNORE$", -"deletedDateTime":"$IGNORE$", -"regCenterId":"$IGNORE$" + "id":"$IGNORE$", + "version":"$IGNORE$", + "responsetime":"$IGNORE$", + "metadata":"$IGNORE$", + "response":{ + "id":"$IGNORE$", + "name":"{{name}}", + "serialNum":"{{serialNum}}", + "deviceSpecId":"{{deviceSpecId}}", + "macAddress":"{{macAddress}}", + "ipAddress":"{{ipAddress}}", + "langCode":"{{langCode}}", + "validityDateTime":"{{validityDateTime}}", + "isActive":"{{isActive}}", + "createdBy":"$IGNORE$", + "createdDateTime":"$IGNORE$", + "updatedBy":"$IGNORE$", + "updatedDateTime":"$IGNORE$", + "isDeleted":"$IGNORE$", + "deletedDateTime":"$IGNORE$", + "regCenterId":"$IGNORE$" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs index f7bfbc450ce..e0381953f1d 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml b/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml index 779d07d61fe..f4829dfdbe2 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/DocumentType/CreateDocumentType.yml @@ -17,7 +17,7 @@ CreateDocumentType: output: '{ "code": "TestDocType0010", "description": "TestDocType0010 Card Holder", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "langCode": "eng", "name": "TestDocType0010 Card" }' @@ -39,7 +39,7 @@ CreateDocumentType: output: '{ "code": "TestDocType0020", "description": "$IGNORE$", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "langCode": "eng", "name": "TestDocType0020 Card" }' diff --git a/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml b/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml index 78383ec851f..da4c48da58b 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml +++ b/automationtests/src/main/resources/masterdata/DocumentType/UpdateDocumentType.yml @@ -17,7 +17,7 @@ UpdateDocumentType: output: '{ "code": "TestDocType0010", "description": "TestDocType0010 Card Holder updated", - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "langCode": "eng", "name": "TestDocType0010 Card" }' diff --git a/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs b/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs index cfd25a3bded..0736ceff345 100644 --- a/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DocumentType/documentTypeResult.hbs @@ -8,7 +8,7 @@ "langCode":"{{langCode}}", "name":"{{name}}", "description":"{{description}}", -"isActive":{{isActive}}, +"isActive":"{{isActive}}", "createdBy":"$IGNORE$", "createdDateTime":"$IGNORE$", "updatedBy":"$IGNORE$", @@ -16,5 +16,5 @@ "isDeleted":"$IGNORE$", "deletedDateTime":"$IGNORE$" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml index 1bad4dc3846..4f6378c5a00 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/FetchAllDeviceTypes.yml @@ -11,7 +11,5 @@ FetchAllDeviceType: }' output: '{ -"data": [{ - - }] + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs index a0c9e367a7a..976e226fb19 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceType/fetchAllDeviceTypesResult.hbs @@ -10,7 +10,7 @@ "data": [ {{#each data}} { - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/FetchAllMachineSpecification.yml b/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/FetchAllMachineSpecification.yml index 8d80bcc0567..4f6378c5a00 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/FetchAllMachineSpecification.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllMachineSpecification/FetchAllMachineSpecification.yml @@ -2,6 +2,7 @@ FetchAllDeviceType: MasterData_FetchAllDeviceTypes_valid_smoke: endPoint: /v1/masterdata/devicetypes/all role: admin + checkErrorsOnlyInResponse: true templateFields: [] restMethod: get inputTemplate: masterdata/FetchAllDeviceType/fetchAllDeviceTypes @@ -10,7 +11,5 @@ FetchAllDeviceType: }' output: '{ -"data": [{ - - }] + }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml b/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml index bbde44ad32b..fc9fc7295d8 100644 --- a/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml +++ b/automationtests/src/main/resources/masterdata/FetchMachine/FetchMachine.yml @@ -43,7 +43,9 @@ FetchMachine: "regCenterId": "10011" }' output: '{ - "isActive": true +"data": [{ + "isActive": "true" + }] }' Masterdata_FetchMachine_inValid_regCenterId: endPoint: /v1/masterdata/machines/mappedmachines/{regCenterId} diff --git a/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs b/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs index b36b8b2217f..39e0b1cebbe 100644 --- a/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMachine/fetchMachineByCenterResult.hbs @@ -15,7 +15,7 @@ "data": [ {{#each data}} { - "isActive": {{isActive}}, + "isActive": "{{isActive}}", "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml b/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml index a4c3ef373c8..ea104bb4cc5 100644 --- a/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml +++ b/automationtests/src/main/resources/masterdata/MachineTypeSearch/MachineTypeSearch.yml @@ -30,7 +30,7 @@ MachineTypeSearch: output: '{ "data": [ { - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "createdBy": "$IGNORE$", "code": "Laptop-2", "langCode": "eng", @@ -63,7 +63,7 @@ MachineTypeSearch: output: '{ "data": [ { - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "createdBy": "$IGNORE$", "code": "$IGNORE$", "langCode": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs b/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs index 7519f46d8e1..2a3b5ce19ea 100644 --- a/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineTypeSearch/machineTypeSearchResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -10,7 +10,7 @@ "data": [ {{#each data}} { - "isActive": {{isActive}}, + "isActive": "{{isActive}}", "createdBy": "{{createdBy}}", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", @@ -26,5 +26,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs index 3b0b96a0a4c..b94198d8a75 100644 --- a/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchBlockListedWords/searchBlockListedWordsResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -10,7 +10,7 @@ "data": [ {{#each data}} { - "isActive": {{isActive}}, + "isActive": "{{isActive}}", "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", @@ -25,5 +25,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml index 504034e147c..469eabea9b7 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/SearchMachineSpec.yml @@ -28,6 +28,7 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -36,7 +37,8 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" + }] }' Masterdata_SearchMachineSpec_Valid_sortType_DESC: endPoint: /v1/masterdata/machinespecifications/search @@ -65,6 +67,7 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -73,7 +76,8 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" + }] }' Masterdata_SearchMachineSpec_Valid_col_as_Model: endPoint: /v1/masterdata/machinespecifications/search @@ -102,6 +106,7 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -110,7 +115,8 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" + }] }' Masterdata_SearchMachineSpec_Valid_col_as_Brand: endPoint: /v1/masterdata/machinespecifications/search @@ -148,7 +154,7 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" }] }' Masterdata_SearchMachineSpec_Valid_col_as_isActive: @@ -178,6 +184,7 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -186,7 +193,8 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" + }] }' Masterdata_SearchMachineSpec_Valid_col_as_Name_FltrTyp_startsWith: endPoint: /v1/masterdata/machinespecifications/search @@ -215,6 +223,7 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -223,7 +232,8 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" + }] }' Masterdata_SearchMachineSpec_Valid_col_as_Name_FltrTyp_contains: endPoint: /v1/masterdata/machinespecifications/search @@ -252,6 +262,7 @@ SearchMachineSpec: "requesttime": "$TIMESTAMP$" }' output: '{ + "data": [{ "id": "$IGNORE$", "name": "HP", "brand": "HP", @@ -260,7 +271,8 @@ SearchMachineSpec: "minDriverversion": "3.2", "description": "HP brand", "langCode": "eng", - "isActive": $IGNORE$ + "isActive": "$IGNORE$" + }] }' Masterdata_SearchMachineSpec_inValid_columnName_blank: endPoint: /v1/masterdata/machinespecifications/search diff --git a/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs index da702751594..941b2bc0a3e 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachineSpec/searchMachineSpecResult.hbs @@ -1,7 +1,8 @@ { - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -15,7 +16,7 @@ "updatedDateTime": "$IGNORE$", "isDeleted": "$IGNORE$", "deletedDateTime": "$IGNORE$", - "isActive": {{isActive}}, + "isActive": "{{isActive}}", "id": "{{id}}", "langCode": "{{langCode}}", "name": "{{name}}", @@ -29,5 +30,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file From 69e52a27c69509e7d664759d458eb65b256cf671 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 23 Aug 2023 15:53:14 +0530 Subject: [PATCH 059/204] MOSIP-29064 --- .../biometricAttributesResult.hbs | 4 +-- .../blockListedWordValidationResult.hbs | 4 +-- .../blockListedWordsResult.hbs | 8 +++--- .../createApplicationTypeResult.hbs | 2 +- .../createBiometricTypeResult.hbs | 2 +- .../CreateIdType/createIdTypeResult.hbs | 2 +- .../decommisionDeviceResult.hbs | 2 +- .../decommisionMachineResult.hbs | 8 +++--- .../decommissionRegCenterResult.hbs | 2 +- .../DeleteDevice/deleteDeviceResult.hbs | 2 +- .../deleteDeviceSpecResult.hbs | 2 +- .../deleteDocumentCategoryResult.hbs | 2 +- .../deleteDocumentTypeResult.hbs | 2 +- .../deleteGenderTypeResult.hbs | 8 +++--- .../DeleteHoliday/deleteHolidayResult.hbs | 2 +- .../DeleteLanguage/deleteLanguageResult.hbs | 2 +- .../DeleteLocation/deleteLocationResult.hbs | 2 +- .../DeleteMachine/deleteMachineResult.hbs | 8 +++--- .../deleteMachineSpecResult.hbs | 8 +++--- .../DeleteRegCenter/deleteRegCenterResult.hbs | 2 +- .../deleteRegCenterTypeResult.hbs | 2 +- .../DeleteTemplate/deleteTemplateResult.hbs | 8 +++--- .../deleteTemplateFileFormatResult.hbs | 2 +- .../deleteUserCenterMappingResult.hbs | 2 +- .../deleteUserDetailsResult.hbs | 2 +- .../deleteValidDocumentResult.hbs | 2 +- .../DeleteZoneUser/deleteZoneUserResult.hbs | 2 +- .../DeviceFilter/deviceFilterResult.hbs | 8 +++--- .../DeviceSearch/deviceSearchResult.hbs | 6 ++--- .../DeviceSpecFilter/DeviceSpecFilter.yml | 2 +- .../deviceSpecFilterResult.hbs | 2 +- .../deviceSpecSearchResult.hbs | 6 ++--- .../deviceSpecificationResult.hbs | 4 +-- .../DeviceType/deviceTypeResult.hbs | 2 +- .../deviceTypeFilterResult.hbs | 8 +++--- .../DeviceTypeSearch/DeviceTypeSearch.yml | 25 +++---------------- .../deviceTypeSearchResult.hbs | 8 +++--- .../documentCategoryResult.hbs | 2 +- .../FetchAllBlockListedWord.yml | 2 +- .../fetchAllBlockListedWordResult.hbs | 2 +- .../FetchAllDeviceSpec/FetchAllDeviceSpec.yml | 2 +- .../fetchAllDeviceSpecResult.hbs | 2 +- .../FetchAllRegCent/fetchAllRegCentResult.hbs | 2 +- .../fetchAllTemplatesResult.hbs | 2 +- .../fetchAllValidDocumentsResult.hbs | 2 +- .../FetchDeviceSpec/fetchDeviceSpecResult.hbs | 2 +- .../fetchDistinctDynamicFieldResult.hbs | 2 +- ...chDistinctDynamicFieldByLangcodeResult.hbs | 2 +- .../fetchDocumentTypesResult.hbs | 2 +- .../fetchDocumentTypesbylangcodeResult.hbs | 2 +- .../fetchDynamicFieldResult.hbs | 2 +- .../FetchGenderType/fetchGenderTypeResult.hbs | 2 +- .../fetchGenderTypeValidationResult.hbs | 8 +++--- .../FetchHolidays/fetchHolidayResult.hbs | 2 +- .../fetchLocationDetailsbyLangcodeResult.hbs | 16 ++++++------ .../fetchLocationImmediatechildrenResult.hbs | 8 +++--- .../fetchLocationValidationResult.hbs | 8 +++--- .../FetchMissingRegCenterTypeDetails.yml | 2 +- .../fetchMissingTemplatesResult.hbs | 2 +- .../masterdata/FetchRegCent/FetchRegCent.yml | 4 +-- .../fetchRegCentValidateResult.hbs | 6 ++--- .../fetchTemplateTypeResult.hbs | 8 +++--- .../fetchWorkingDaysResult.hbs | 2 +- .../filterBlockListedWordsResult.hbs | 8 +++--- .../filterDocCategoryResult.hbs | 8 +++--- .../filterDocumentTypeResult.hbs | 8 +++--- .../filterDynamicFieldResult.hbs | 8 +++--- .../FilterHolidays/filterHolidaysResult.hbs | 8 +++--- .../filterLocationDataResult.hbs | 8 +++--- .../filterMachineSpecResult.hbs | 8 +++--- .../filterMachineTypeResult.hbs | 8 +++--- .../FilterMachines/filterMachinesResult.hbs | 8 +++--- .../filterRegCenterTypeResult.hbs | 6 ++--- .../filterTemplateDetailsResult.hbs | 6 ++--- .../filterZoneDetailsResult.hbs | 6 ++--- .../masterdata/Gender/genderResult.hbs | 2 +- .../GenderFilter/genderFilterResult.hbs | 6 ++--- .../masterdata/GenderSearch/searchResult.hbs | 4 +-- .../allTxnDetailsResult.hbs | 8 +++--- .../getApplicantTypeResult.hbs | 2 +- .../getApplicationConfigsResult.hbs | 2 +- ...ApplicationTypeByCodeAndLangcodeResult.hbs | 2 +- .../getApplicationTypesResult.hbs | 2 +- .../getApplicationTypesByLangcodeResult.hbs | 2 +- ...getBiometricAttributesByAuthTypeResult.hbs | 8 +++--- ...etBiometricTypeByCodeAndLangcodeResult.hbs | 2 +- .../getBiometricTypesResult.hbs | 2 +- .../getBiometricTypesByLangcodeResult.hbs | 2 +- .../GetDocCategory/getDocCategoryResult.hbs | 8 +++--- .../getDocCategoryByLangCodeResult.hbs | 8 +++--- .../getDocumentTypeByLangCodeResult.hbs | 8 +++--- .../getExceptionalHolidaysResult.hbs | 8 +++--- .../getHolidaysMissingIdsResult.hbs | 8 +++--- .../getIdTypeByLangCodeResult.hbs | 8 +++--- .../GetLanguage/getLanguageResult.hbs | 8 +++--- .../getLeafZonesByLangCodeResult.hbs | 6 ++--- .../getLeafsByLangCodeResult.hbs | 6 ++--- ...LocationHierarchyByHierarchyNameResult.hbs | 8 +++--- ...nHierarchyLevelByLastUpdatedDateResult.hbs | 8 +++--- .../GetLocations/getLocationsResult.hbs | 8 +++--- .../getMachineHistoryResult.hbs | 8 +++--- .../GetMachines/getMachinesResult.hbs | 8 +++--- ...issingDocumentCategoryByLangcodeResult.hbs | 8 +++--- ...getMissingDocumentTypeByLangcodeResult.hbs | 10 ++++---- .../getModuleByIdLangCodeResult.hbs | 8 +++--- .../getModuleByLangCodeResult.hbs | 8 +++--- .../getPacketRejectionReasonResult.hbs | 2 +- .../getPossiableValuesResult.hbs | 8 +++--- .../getSubZoneByLangCodeResult.hbs | 6 ++--- .../getTemplateFileFormatResult.hbs | 2 +- .../GetTemplateType/templateTypeResult.hbs | 8 +++--- .../GetTemplateType/templateTypeResult.hbs | 8 +++--- .../GetTemplates/getTemplatesResult.hbs | 8 +++--- .../getTemplatesByCodeResult.hbs | 6 ++--- .../getUserDetailsByIDResult.hbs | 6 ++--- .../GetUserDetails/getUserDetailsResult.hbs | 6 ++--- .../getValidDocumentResult.hbs | 6 ++--- .../GetWeekDay/getWeekDayResult.hbs | 6 ++--- .../getZoneHierarchyByLangCodeResult.hbs | 6 ++--- .../getZoneUserWithEffDateResult.hbs | 8 +++--- ...timmediateChildrenByLocationCodeResult.hbs | 8 +++--- .../masterdata/Holiday/holidayResult.hbs | 2 +- .../HolidaySearch/holidaySearchResult.hbs | 4 +-- .../IdSchema/createIdSchemaResult.hbs | 2 +- .../masterdata/Language/languageResult.hbs | 2 +- .../LocationData/locationDataResult.hbs | 2 +- .../masterdata/Machine/machineResult.hbs | 2 +- .../MachineSpecificationResult.hbs | 2 +- .../MachineType/machineTypeResult.hbs | 2 +- .../packetRejectionReasonCategoryResult.hbs | 2 +- .../packetRejectionReasonListResult.hbs | 2 +- .../RegCenterFilter/regCenterFilterResult.hbs | 6 ++--- .../RegCenterSearch/regCenterSearchResult.hbs | 18 ++++++------- .../RegCenterType/regCenterTypeResult.hbs | 2 +- .../registrationCenterResult.hbs | 2 +- .../RejectionList/rejectionListResult.hbs | 2 +- .../RejectionReason/rejectionReasonResult.hbs | 2 +- .../searchDocCategoriesResult.hbs | 8 +++--- .../searchDocumentTypeResult.hbs | 8 +++--- .../searchDynamicFieldResult.hbs | 2 +- .../searchDocumentTypeResult.hbs | 8 +++--- .../searchLocationDataResult.hbs | 6 ++--- .../SearchMachine/searchMachineResult.hbs | 6 ++--- .../searchPacketResult.hbs | 2 +- .../searchRegCenterTypeResult.hbs | 4 +-- .../searchTemplateDetailsResult.hbs | 4 +-- .../searchUserCenterMappingResult.hbs | 2 +- .../SearchZoneUser/searchZoneUserResult.hbs | 6 ++--- .../masterdata/Template/templateResult.hbs | 2 +- .../templateFileFormatResult.hbs | 2 +- .../TemplateType/templateTypeResult.hbs | 2 +- .../masterdata/Title/titleResult.hbs | 2 +- .../TitleFilter/titleFilterResult.hbs | 6 ++--- .../TitleSearch/titleSearchResult.hbs | 4 +-- .../updateblockListedWordDetailsResult.hbs | 8 +++--- .../updateDeviceStatusResult.hbs | 8 +++--- .../updateDeviceTypeResult.hbs | 8 +++--- .../updateteDeviceTypeStatusResult.hbs | 8 +++--- .../updateDocCategoryResult.hbs | 8 +++--- .../UpdateDocType/updateDocTypeResult.hbs | 8 +++--- .../updateHolidayStatusResult.hbs | 8 +++--- .../UpdateIdSchema/updateIdSchemaResult.hbs | 8 +++--- .../UpdateLanguage/updateLanguageResult.hbs | 8 +++--- .../updateLocationStatusResult.hbs | 8 +++--- ...dateteMachineSpecificationStatusResult.hbs | 8 +++--- .../updateteMachineStatusResult.hbs | 8 +++--- .../updateteMachineTypeStatusResult.hbs | 6 ++--- .../updateRegCenterTypeStatusResult.hbs | 8 +++--- .../updateRegistrationCenterResult.hbs | 6 ++--- .../updateRegistrationCenterResult.hbs | 2 +- .../updateTemplateStatusResult.hbs | 8 +++--- .../UpdateUISpec/updateUISpecResult.hbs | 8 +++--- .../updateUserCenterMappingStatusResult.hbs | 8 +++--- .../updateZoneUserStatusResult.hbs | 8 +++--- .../userCenterMappingResult.hbs | 2 +- .../ValidDocument/validDocumentResult.hbs | 2 +- .../validDocumentFilterResult.hbs | 8 +++--- .../validDocumentMapResult.hbs | 6 ++--- .../validDocumentSearchResult.hbs | 2 +- .../validDocumentUnMapResult.hbs | 6 ++--- .../masterdata/ZoneUser/zoneUserResult.hbs | 2 +- ...trationmachineusermappinghistoryResult.hbs | 8 +++--- 182 files changed, 463 insertions(+), 482 deletions(-) diff --git a/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs b/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs index 207467c9854..9810c5cc3ae 100644 --- a/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs +++ b/automationtests/src/main/resources/masterdata/BiometricAttributes/biometricAttributesResult.hbs @@ -1,6 +1,6 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "code": "{{code}}", diff --git a/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs b/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs index 03e02d7eef9..e87776bc8b1 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs +++ b/automationtests/src/main/resources/masterdata/BlockListedWordValidation/blockListedWordValidationResult.hbs @@ -2,9 +2,9 @@ "id": "$IGNORE$", "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "code": "{{code}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs index b2f6d83534e..785daa1b983 100644 --- a/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/BlockListedWords/blockListedWordsResult.hbs @@ -1,11 +1,11 @@ { -"id":"string", -"version":"string", +"id":"$IGNORE$", +"version":"$IGNORE$", "responsetime":"$IGNORE$", -"metadata":null, +"metadata":"$IGNORE$", "response":{ "word":"{{word}}", "langCode":"{{langCode}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateApplicationType/createApplicationTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateBiometricType/createBiometricTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs b/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs index 3365fb263eb..4b99d7229ae 100644 --- a/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/CreateIdType/createIdTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/DecommisionDevice/decommisionDeviceResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs b/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs index ab2d4d0fe60..be92406a1bf 100644 --- a/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/DecommisionMachine/decommisionMachineResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DecommissionRegCenter/decommissionRegCenterResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDevice/deleteDeviceResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDeviceSpec/deleteDeviceSpecResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs index 04c31e632fc..52690f1776c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDocumentCategory/deleteDocumentCategoryResult.hbs @@ -6,5 +6,5 @@ "response":{ "code":"{{code}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs index 04c31e632fc..52690f1776c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteDocumentType/deleteDocumentTypeResult.hbs @@ -6,5 +6,5 @@ "response":{ "code":"{{code}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs index 20603926c4a..e87776bc8b1 100644 --- a/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteGenderType/deleteGenderTypeResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "code": "{{code}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs b/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs index eb6ea7927bf..97b1a05caa6 100644 --- a/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteHoliday/deleteHolidayResult.hbs @@ -7,5 +7,5 @@ "locationCode": "{{locationCode}}", "holidayDate": "{{holidayDate}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs b/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs index 3c82a91f480..b2d43a113d7 100644 --- a/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteLanguage/deleteLanguageResult.hbs @@ -4,5 +4,5 @@ "responsetime": "$IGNORE$", "metadata": "$IGNORE$", "response": "$IGNORE$", - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs b/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs index 04c31e632fc..52690f1776c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteLocation/deleteLocationResult.hbs @@ -6,5 +6,5 @@ "response":{ "code":"{{code}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs b/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs index ab2d4d0fe60..be92406a1bf 100644 --- a/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteMachine/deleteMachineResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs index ab2d4d0fe60..be92406a1bf 100644 --- a/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteMachineSpec/deleteMachineSpecResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs b/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteRegCenter/deleteRegCenterResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs index 04c31e632fc..52690f1776c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteRegCenterType/deleteRegCenterTypeResult.hbs @@ -6,5 +6,5 @@ "response":{ "code":"{{code}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs b/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs index ab2d4d0fe60..be92406a1bf 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteTemplate/deleteTemplateResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs index 04c31e632fc..52690f1776c 100644 --- a/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteTemplateFileFormat/deleteTemplateFileFormatResult.hbs @@ -6,5 +6,5 @@ "response":{ "code":"{{code}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteUserCenterMapping/deleteUserCenterMappingResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs b/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteUserDetails/deleteUserDetailsResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs b/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs index a8f8da6c227..554c54f91d6 100644 --- a/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteValidDocument/deleteValidDocumentResult.hbs @@ -7,5 +7,5 @@ "docCategoryCode":"{{docCategoryCode}}", "doctypecode":"{{doctypecode}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs b/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs index d6c895580c0..cd3497386da 100644 --- a/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeleteZoneUser/deleteZoneUserResult.hbs @@ -6,5 +6,5 @@ "response":{ "id":"{{id}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceFilter/deviceFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs index 2fce8793ff1..5eaa612e1f2 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSearch/deviceSearchResult.hbs @@ -1,7 +1,7 @@ { - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -30,5 +30,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml index 71bf2799f02..9ddd165a77b 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml +++ b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/DeviceSpecFilter.yml @@ -170,6 +170,7 @@ DeviceSpecFilter: MasterData_DeviceSpecFilter_Invalid_Value_Name_neg: endPoint: /v1/masterdata/devicespecifications/filtervalues role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceSpecFilter/deviceSpecFilter @@ -184,7 +185,6 @@ DeviceSpecFilter: "requesttime": "$TIMESTAMP$" }' output: '{ - "filters": [] }' MasterData_DeviceSpecFilter_Invalid_FilterType_neg: endPoint: /v1/masterdata/devicespecifications/filtervalues diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs index e0381953f1d..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecFilter/deviceSpecFilterResult.hbs @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs index bd26e16fa8b..b319d2ef4bb 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecSearch/deviceSpecSearchResult.hbs @@ -1,7 +1,7 @@ { - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -30,5 +30,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs index c037050d67d..cc257ce817b 100644 --- a/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceSpecification/deviceSpecificationResult.hbs @@ -1,11 +1,11 @@ { "id": "$IGNORE$", - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs b/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceType/deviceTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceTypeFilter/deviceTypeFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml index 677e12bcfb7..78fa690c9a6 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml +++ b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/DeviceTypeSearch.yml @@ -42,6 +42,7 @@ DeviceTypeSearch: MasterData_DeviceTypeSearch_Equals_isActive_eng_smoke: endPoint: /v1/masterdata/devicetypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceTypeSearch/deviceTypeSearch @@ -75,16 +76,7 @@ DeviceTypeSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$" - } - ] + }' MasterData_DeviceTypeSearch_Contains_Name_eng_smoke: endPoint: /v1/masterdata/devicetypes/search @@ -129,6 +121,7 @@ DeviceTypeSearch: MasterData_DeviceTypeSearch_startsWith_Name_eng_smoke: endPoint: /v1/masterdata/devicetypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["languageCode"] restMethod: post inputTemplate: masterdata/DeviceTypeSearch/deviceTypeSearch @@ -155,20 +148,11 @@ DeviceTypeSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [ - { - "isActive": "$IGNORE$", - "createdBy": "$IGNORE$", - "code": "$IGNORE$", - "langCode": "$IGNORE$", - "name": "$IGNORE$", - "description": "$IGNORE$" - } - ] }' MasterData_DeviceTypeSearch_Invalid_Value_Name_smoke: endPoint: /v1/masterdata/devicetypes/search role: admin + checkErrorsOnlyInResponse: true templateFields: ["value"] restMethod: post inputTemplate: masterdata/DeviceTypeSearch/deviceTypeSearch @@ -195,7 +179,6 @@ DeviceTypeSearch: "requesttime": "$TIMESTAMP$" }' output: '{ - "data": [] }' MasterData_DeviceTypeSearch_Invalid_ColumnName_neg: endPoint: /v1/masterdata/devicetypes/search diff --git a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs index eb14eac82af..2a3b5ce19ea 100644 --- a/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/DeviceTypeSearch/deviceTypeSearchResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -26,5 +26,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs b/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/DocumentCategory/documentCategoryResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml index f248bfaba96..1073a776ee2 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/FetchAllBlockListedWord.yml @@ -2,11 +2,11 @@ FetchAllBlockListedWord: Kernel_FetchAllBlockListedWord_valid_smoke: endPoint: /v1/masterdata/blocklistedwords/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllBlockListedWord/fetchAllBlockListedWord outputTemplate: masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult input: '{ }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs index ff510672668..11f76f039af 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllBlockListedWord/fetchAllBlockListedWordResult.hbs @@ -25,5 +25,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/FetchAllDeviceSpec.yml b/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/FetchAllDeviceSpec.yml index 60126a5e394..bac0d96d059 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/FetchAllDeviceSpec.yml +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/FetchAllDeviceSpec.yml @@ -2,6 +2,7 @@ FetchAllDeviceSpec: MasterData_FetchAllDeviceSpec_AllValid_smoke: endPoint: /v1/masterdata/devicespecifications/all role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchAllDeviceSpec/fetchAllDeviceSpec outputTemplate: masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult @@ -9,5 +10,4 @@ FetchAllDeviceSpec: }' output: '{ - "errors": null }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs index 9cc9adbe807..5489fd53606 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllDeviceSpec/fetchAllDeviceSpecResult.hbs @@ -9,5 +9,5 @@ "totalItems": "$IGNORE$", "data": "$IGNORE$" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs index fbbe61484f5..b248115e390 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllRegCent/fetchAllRegCentResult.hbs @@ -11,5 +11,5 @@ "totalItems": "$IGNORE$", "data": "$IGNORE$" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs index 9cc9adbe807..5489fd53606 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllTemplates/fetchAllTemplatesResult.hbs @@ -9,5 +9,5 @@ "totalItems": "$IGNORE$", "data": "$IGNORE$" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs b/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs index 3977376f962..adccc9a07e4 100644 --- a/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchAllValidDocuments/fetchAllValidDocumentsResult.hbs @@ -25,5 +25,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs index b681d8bae44..4f8fae21c13 100644 --- a/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDeviceSpec/fetchDeviceSpecResult.hbs @@ -21,5 +21,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs index e23b6c390ea..394dc56d52d 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicField/fetchDistinctDynamicFieldResult.hbs @@ -4,5 +4,5 @@ "responsetime": "$IGNORE$", "metadata": "$IGNORE$", "response": "$IGNORE$", - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs index c798b263e15..f9bfab29266 100644 --- a/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDistinctDynamicFieldByLangcode/fetchDistinctDynamicFieldByLangcodeResult.hbs @@ -13,5 +13,5 @@ {{#unless @last}},{{/unless}} {{/each}} ], - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs index be361eb0d13..9ff4dd9de63 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesResult.hbs @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs index be361eb0d13..9ff4dd9de63 100644 --- a/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDocumentTypes/fetchDocumentTypesbylangcodeResult.hbs @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs index 52229062b6b..5b9464e9bb8 100644 --- a/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchDynamicField/fetchDynamicFieldResult.hbs @@ -36,5 +36,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs index c6f216f8e48..d2f85ecb48b 100644 --- a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeResult.hbs @@ -16,5 +16,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchGenderType/fetchGenderTypeValidationResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs b/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs index 46446c2106a..ee73b87ab2e 100644 --- a/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchHolidays/fetchHolidayResult.hbs @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs index 02437c7c524..324d8aeeb00 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationDetailsbyLangcodeResult.hbs @@ -1,16 +1,16 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "isActive": true, "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", - "updatedBy": null, - "updatedDateTime": null, - "isDeleted": null, - "deletedDateTime": null, + "updatedBy": "$IGNORE$", + "updatedDateTime": "$IGNORE$", + "isDeleted": "$IGNORE$", + "deletedDateTime": "$IGNORE$", "code": "$IGNORE$", "name": "$IGNORE$", "hierarchyLevel": $IGNORE$, @@ -18,5 +18,5 @@ "parentLocCode": "$IGNORE$", "langCode": "$IGNORE$" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs index bcdaa334768..d391846c02e 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationImmediatechildrenResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "locations": [ {{#each locations}} @@ -19,5 +19,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchLocation/fetchLocationValidationResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/FetchMissingRegCenterTypeDetails.yml b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/FetchMissingRegCenterTypeDetails.yml index 3a5284214f7..63a2d51aee8 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/FetchMissingRegCenterTypeDetails.yml +++ b/automationtests/src/main/resources/masterdata/FetchMissingRegCenterTypeDetails/FetchMissingRegCenterTypeDetails.yml @@ -2,6 +2,7 @@ FetchMissingRegCenterTypeDetails: MasterData_FetchMissingRegCenterTypeDetails_valid_smoke: endPoint: /v1/masterdata/registrationcentertypes/missingids/{langcode} role: admin + checkErrorsOnlyInResponse: true restMethod: get inputTemplate: masterdata/FetchMissingRegCenterTypeDetails/fetchMissingRegCenterTypeDetails outputTemplate: masterdata/FetchMissingRegCenterTypeDetails/fetchMissingRegCenterTypeDetailsResult @@ -9,5 +10,4 @@ FetchMissingRegCenterTypeDetails: "langcode": "eng" }' output: '{ - "response": "$IGNORE$" }' \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs index 70cdd508932..6f535a41eda 100644 --- a/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchMissingTemplates/fetchMissingTemplatesResult.hbs @@ -3,6 +3,6 @@ "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": "$IGNORE$", - "response": $IGNORE$, + "response": "$IGNORE$", "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml index 8b72400c8f0..eebb6bcce5b 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/FetchRegCent.yml @@ -250,6 +250,7 @@ FetchRegCent: MasterData_FetchRegCent_By_HierarchyLevel_Text_langCode_allValid_smoke: endPoint: /v1/masterdata/registrationcenters/{langcode}/{hierarchylevel}/{name} role: admin + checkErrorsOnlyInResponse: true templateFields: ["langcode"] restMethod: get inputTemplate: masterdata/FetchRegCent/fetchRegCent @@ -269,9 +270,6 @@ FetchRegCent: "timestamp": "$REMOVE$" }' output: '{ -"registrationCenters": [{ - "langCode": "$IGNORE$" - }] }' MasterData_FetchRegCent_By_HierarchyLevel_Text_langCode_invalid_hierarchylevel: diff --git a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs index 54c0fab250c..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchRegCent/fetchRegCentValidateResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, diff --git a/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs b/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs index ce2efbe4998..6bac5f834cd 100644 --- a/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchTemplateType/fetchTemplateTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "templateTypes": [ {{#each templateTypes}} @@ -16,5 +16,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs b/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs index 9364f828d47..0257792844a 100644 --- a/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs +++ b/automationtests/src/main/resources/masterdata/FetchWorkingDays/fetchWorkingDaysResult.hbs @@ -16,5 +16,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs b/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterBlockListedWords/filterBlockListedWordsResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterDocCategory/filterDocCategoryResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterDocumentType/filterDocumentTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs index e1505f2346d..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterDynamicField/filterDynamicFieldResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs b/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterHolidays/filterHolidaysResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs b/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs index f7bfbc450ce..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterLocationData/filterLocationDataResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs b/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs index 6adabd4834a..e57af980266 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterMachineSpec/filterMachineSpecResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs b/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs index 6adabd4834a..e57af980266 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterMachineType/filterMachineTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs b/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs index 6adabd4834a..e57af980266 100644 --- a/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterMachines/filterMachinesResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": [] + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs index 15dd7eae3ee..15c1554caa7 100644 --- a/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterRegCenterType/filterRegCenterTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs index f7bfbc450ce..e0381953f1d 100644 --- a/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterTemplateDetails/filterTemplateDetailsResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs b/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs index 5d9799a8646..224a3490f5a 100644 --- a/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/FilterZoneDetails/filterZoneDetailsResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs b/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs +++ b/automationtests/src/main/resources/masterdata/Gender/genderResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs b/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs index f7bfbc450ce..e0381953f1d 100644 --- a/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/GenderFilter/genderFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs b/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs index 6271222484a..712f5d3bdf8 100644 --- a/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs +++ b/automationtests/src/main/resources/masterdata/GenderSearch/searchResult.hbs @@ -1,6 +1,6 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs index ba65c9c0c22..210d28a8d9c 100644 --- a/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetAllTxnDetailBulkUpload/allTxnDetailsResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "pageNo": 0, "totalPages": $IGNORE$, @@ -18,7 +18,7 @@ "statusDescription": "$IGNORE$", "uploadedBy": "$IGNORE$", "timeStamp": "$IGNORE$", - "logs": null + "logs": "$IGNORE$" } ] }, diff --git a/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs index 442ea74015b..c84dd462a30 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicantType/getApplicantTypeResult.hbs @@ -1,5 +1,5 @@ { - "id": "mosip.applicanttype.fetch", + "id": "$IGNORE$", "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs index 8ae2a9c3913..684802f0781 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationConfigs/getApplicationConfigsResult.hbs @@ -1,6 +1,6 @@ { "id": "$IGNORE$", - "version": "{{version}}", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "metadata": "$IGNORE$", "response": { diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs index 040a2b52b9c..7e1abe85d36 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypeByCodeAndLangcode/getApplicationTypeByCodeAndLangcodeResult.hbs @@ -14,5 +14,5 @@ } ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs index 0ee24a83350..fd9b4315b93 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypes/getApplicationTypesResult.hbs @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs index 11078e0620e..8936db69712 100644 --- a/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetApplicationTypesByLangcode/getApplicationTypesByLangcodeResult.hbs @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs index 560a55432fa..d1e1999d620 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricAttributesByAuthType/getBiometricAttributesByAuthTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "biometricattributes": [ @@ -19,5 +19,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs index a590e320f72..2110a214f2e 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypeByCodeAndLangcode/getBiometricTypeByCodeAndLangcodeResult.hbs @@ -14,5 +14,5 @@ } ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs index 34de5d2a839..1ac3563a1ea 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypes/getBiometricTypesResult.hbs @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs index 86e1971fe1f..66564377c5d 100644 --- a/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetBiometricTypesByLangcode/getBiometricTypesByLangcodeResult.hbs @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs index ac828738d36..fb00f984501 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocCategory/getDocCategoryResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "documentcategories": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs index ac828738d36..fb00f984501 100644 --- a/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocCategoryByLangCode/getDocCategoryByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "documentcategories": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs index 8fcc69c1bd4..2daaaf4a3b1 100644 --- a/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetDocumentTypeByLangCode/getDocumentTypeByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "documenttypes": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs index 5a7ad7fcf3d..9fc9b5e6b97 100644 --- a/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetExceptionalHolidays/getExceptionalHolidaysResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "exceptionalHolidayList": [ @@ -23,5 +23,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs b/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs index 5af99cd626b..f0230fac330 100644 --- a/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetHolidaysMissingIds/getHolidaysMissingIdsResult.hbs @@ -1,12 +1,12 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}", "fieldValue": "{{fieldValue}}", "langCode": "$IGNORE$" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs index 56fe4390518..125b2e42cf9 100644 --- a/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetIdTypeByLangCode/getIdTypeByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "idtypes": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs b/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs index 171eb7ec224..dfb7b89deba 100644 --- a/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLanguage/getLanguageResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "languages": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs index ff70d64d962..69245104539 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLeafZonesByLangCode/getLeafZonesByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "isActive": $IGNORE$, "createdBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs index ff70d64d962..69245104539 100644 --- a/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLeafsByLangCode/getLeafsByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "isActive": $IGNORE$, "createdBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs index 66028665926..a8b06b7466b 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyByHierarchyName/getLocationHierarchyByHierarchyNameResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "locations": [ @@ -20,5 +20,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs index c23e9710fc9..c5e0dd4f7ff 100644 --- a/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocationHierarchyLevelByLastUpdatedDate/getLocationHierarchyLevelByLastUpdatedDateResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "locationHierarchyLevels": [ @@ -17,5 +17,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs b/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs index 1a0180f84df..be04da35a6f 100644 --- a/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetLocations/getLocationsResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "pageNo": $IGNORE$, "totalPages": $IGNORE$, @@ -29,5 +29,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs b/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs index f24d55c0f08..4e12bcdec4c 100644 --- a/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMachineHistory/getMachineHistoryResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "machineHistoryDetails": [ @@ -23,5 +23,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs b/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs index 8f423c8fd10..7fce7f49b14 100644 --- a/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMachines/getMachinesResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "machines": [ @@ -26,5 +26,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs index 62898621182..58154a9d79a 100644 --- a/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMissingDocumentCategoryByLangcode/getMissingDocumentCategoryByLangcodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": [ { "id": "{{id}}", @@ -10,5 +10,5 @@ "langCode": "$IGNORE$" } ], - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs b/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs index 7246df897bd..57adfa4bf80 100644 --- a/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetMissingDocumentTypeByLangcode/getMissingDocumentTypeByLangcodeResult.hbs @@ -1,17 +1,17 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": [ {{#each response}} { "id": "{{id}}", - "fieldValue": null, + "fieldValue": "$IGNORE$", "langCode": "$IGNORE$" } {{#unless @last}},{{/unless}} {{/each}} ], - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs index 9ec61bd311b..d9106365621 100644 --- a/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetModuleByIdLangCode/getModuleByIdLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "modules": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs index 9ec61bd311b..d9106365621 100644 --- a/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetModuleByLangCode/getModuleByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "modules": [ @@ -18,5 +18,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs b/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs index 051f02a20bc..4fe46f84ed5 100644 --- a/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetPacketRejectionReason/getPacketRejectionReasonResult.hbs @@ -30,5 +30,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs b/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs index d405628569f..43c838226f5 100644 --- a/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetPossiableValues/getPossiableValuesResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "eng": [ {{#each eng}} @@ -15,5 +15,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs index ff70d64d962..69245104539 100644 --- a/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetSubZoneByLangCode/getSubZoneByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "isActive": $IGNORE$, "createdBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs index 8a551a9c540..47164eb60b6 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplateFileFormat/getTemplateFileFormatResult.hbs @@ -16,5 +16,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs index ce2efbe4998..6bac5f834cd 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplateType/GetTemplateType/templateTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "templateTypes": [ {{#each templateTypes}} @@ -16,5 +16,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs index ce2efbe4998..6bac5f834cd 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplateType/templateTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "templateTypes": [ {{#each templateTypes}} @@ -16,5 +16,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs index f931b35c804..634308ac1f3 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplates/getTemplatesResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "templates": [ {{#each templates}} @@ -23,5 +23,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs index 2fa2e9e9ccf..7036ffb8165 100644 --- a/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetTemplatesByCode/getTemplatesByCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "templates": [ {{#each templates}} diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs index bb4ae0860d4..f1c38ebe483 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsByIDResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}", diff --git a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs index bb4ae0860d4..f1c38ebe483 100644 --- a/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetUserDetails/getUserDetailsResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "id": "{{id}}", "langCode": "{{langCode}}", diff --git a/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs b/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs index 1d7016b0553..983c7719b80 100644 --- a/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetValidDocument/getValidDocumentResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": [{ "docTypeCode": "$IGNORE$", "docCategoryCode": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs b/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs index f95cb84a4c4..6fb82f996e3 100644 --- a/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetWeekDay/getWeekDayResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "weekdays": [ {{#each weekdays}} diff --git a/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs index ff70d64d962..69245104539 100644 --- a/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetZoneHierarchyByLangCode/getZoneHierarchyByLangCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "isActive": $IGNORE$, "createdBy": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs b/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs index e4401fb981a..bb113bb028c 100644 --- a/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetZoneUserWithEffDate/getZoneUserWithEffDateResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "userResponseDto": [ {{#each userResponseDto}} @@ -21,5 +21,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs index 66028665926..a8b06b7466b 100644 --- a/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs +++ b/automationtests/src/main/resources/masterdata/GetimmediateChildrenByLocationCode/getimmediateChildrenByLocationCodeResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "locations": [ @@ -20,5 +20,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs b/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs index ba25469e3a7..d6fe6160506 100644 --- a/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs +++ b/automationtests/src/main/resources/masterdata/Holiday/holidayResult.hbs @@ -10,5 +10,5 @@ "holidayName": "{{holidayName}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs b/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs index 6c46ac487a8..c240395d035 100644 --- a/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/HolidaySearch/holidaySearchResult.hbs @@ -2,7 +2,7 @@ "id": "string", "version": "string", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -28,5 +28,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs b/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs index a1cc53483c4..2d0b9b487ef 100644 --- a/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs +++ b/automationtests/src/main/resources/masterdata/IdSchema/createIdSchemaResult.hbs @@ -16,5 +16,5 @@ "createdOn": "$IGNORE$", "updatedOn": "$IGNORE$" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Language/languageResult.hbs b/automationtests/src/main/resources/masterdata/Language/languageResult.hbs index 2fea1b15d2f..e401ccc9364 100644 --- a/automationtests/src/main/resources/masterdata/Language/languageResult.hbs +++ b/automationtests/src/main/resources/masterdata/Language/languageResult.hbs @@ -6,5 +6,5 @@ "response":{ "code": "{{code}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs b/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs index 8c78e369f7d..0c2fe7c27db 100644 --- a/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs +++ b/automationtests/src/main/resources/masterdata/LocationData/locationDataResult.hbs @@ -18,5 +18,5 @@ "parentLocCode":"{{parentLocCode}}", "langCode":"{{langCode}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs b/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs index 7f04fababb7..43ed584b5e7 100644 --- a/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs +++ b/automationtests/src/main/resources/masterdata/Machine/machineResult.hbs @@ -22,5 +22,5 @@ "regCenterId":"$IGNORE$", "signPublicKey":"$IGNORE$" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs b/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs index 7b174e829a5..cc257ce817b 100644 --- a/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineSpecification/MachineSpecificationResult.hbs @@ -7,5 +7,5 @@ "id": "{{id}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs b/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/MachineType/machineTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs index 1d3be5a21c7..d6832a588f4 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonCategory/packetRejectionReasonCategoryResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs index 8e694587f0d..551bcc91374 100644 --- a/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs +++ b/automationtests/src/main/resources/masterdata/PacketRejectionReasonList/packetRejectionReasonListResult.hbs @@ -8,5 +8,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs index f7bfbc450ce..e0381953f1d 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterFilter/regCenterFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs index 975454dabd8..31bb3911ca0 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterSearch/regCenterSearchResult.hbs @@ -1,7 +1,7 @@ { - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -9,12 +9,12 @@ "data": [ {{#each data}} { - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, + "isDeleted": "$IGNORE$", "deletedDateTime": "$IGNORE$", "id": "$IGNORE$", "name": "{{name}}", @@ -31,7 +31,7 @@ "contactPhone": "$IGNORE$", "workingHours": "$IGNORE$", "langCode": "{{langCode}}", - "numberOfKiosks": $IGNORE$, + "numberOfKiosks": "$IGNORE$", "perKioskProcessTime": "$IGNORE$", "centerStartTime": "$IGNORE$", "centerEndTime": "$IGNORE$", @@ -39,9 +39,9 @@ "contactPerson": "$IGNORE$", "lunchStartTime": "$IGNORE$", "lunchEndTime": "$IGNORE$", - "devices": $IGNORE$, - "machines": $IGNORE$, - "users": $IGNORE$, + "devices": "$IGNORE$", + "machines": "$IGNORE$", + "users": "$IGNORE$", "province": "$IGNORE$", "provinceCode": "$IGNORE$", "region": "$IGNORE$", @@ -60,5 +60,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegCenterType/regCenterTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs index 24366f7bff4..f0b49e09f4f 100644 --- a/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/RegistrationCenterr/registrationCenterResult.hbs @@ -42,5 +42,5 @@ } ] }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs b/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs index e230a8a6757..fcbbee2bbe1 100644 --- a/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs +++ b/automationtests/src/main/resources/masterdata/RejectionList/rejectionListResult.hbs @@ -8,5 +8,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs b/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs index 4587290cb12..1bef69c3fcc 100644 --- a/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs +++ b/automationtests/src/main/resources/masterdata/RejectionReason/rejectionReasonResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs b/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs index ed8d83662e5..c11ddc3756f 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDocCategories/searchDocCategoriesResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -26,5 +26,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs index ed8d83662e5..c11ddc3756f 100644 --- a/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDocumentType/searchDocumentTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -26,5 +26,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs b/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs index f64fe30b50e..dc3f74eae34 100644 --- a/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchDynamicField/searchDynamicFieldResult.hbs @@ -32,5 +32,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } diff --git a/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs index ed8d83662e5..c11ddc3756f 100644 --- a/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchHoliday/searchDocumentTypeResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -26,5 +26,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs b/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs index d6511416745..91d29bc1abf 100644 --- a/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchLocationData/searchLocationDataResult.hbs @@ -1,7 +1,7 @@ { - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -22,5 +22,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs index c87d0619c0b..915e17629f5 100644 --- a/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchMachine/searchMachineResult.hbs @@ -1,7 +1,7 @@ { - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -30,5 +30,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs b/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs index d5fbef94100..38ebfe90aa2 100644 --- a/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchPacketWorkflow/searchPacketResult.hbs @@ -27,5 +27,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs b/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs index b28e0725a20..c3464f92e75 100644 --- a/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchRegCenterType/searchRegCenterTypeResult.hbs @@ -1,6 +1,6 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs b/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs index 037f3e24d82..0369f3d0220 100644 --- a/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchTemplateDetails/searchTemplateDetailsResult.hbs @@ -1,6 +1,6 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs index 8edca7dabf7..7b3f3df2392 100644 --- a/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchUserCenterMapping/searchUserCenterMappingResult.hbs @@ -28,5 +28,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs b/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs index afc84f25a89..55fb0275e44 100644 --- a/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/SearchZoneUser/searchZoneUserResult.hbs @@ -1,7 +1,7 @@ { - "version": "string", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", "toRecord": "$IGNORE$", @@ -19,5 +19,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Template/templateResult.hbs b/automationtests/src/main/resources/masterdata/Template/templateResult.hbs index 7b174e829a5..cc257ce817b 100644 --- a/automationtests/src/main/resources/masterdata/Template/templateResult.hbs +++ b/automationtests/src/main/resources/masterdata/Template/templateResult.hbs @@ -7,5 +7,5 @@ "id": "{{id}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs b/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs +++ b/automationtests/src/main/resources/masterdata/TemplateFileFormat/templateFileFormatResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs b/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/TemplateType/templateTypeResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/Title/titleResult.hbs b/automationtests/src/main/resources/masterdata/Title/titleResult.hbs index 56cf20feb46..e857d744f99 100644 --- a/automationtests/src/main/resources/masterdata/Title/titleResult.hbs +++ b/automationtests/src/main/resources/masterdata/Title/titleResult.hbs @@ -7,5 +7,5 @@ "code": "{{code}}", "langCode": "{{langCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs b/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs index f7bfbc450ce..e0381953f1d 100644 --- a/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/TitleFilter/titleFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} diff --git a/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs b/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs index 8652063a1f2..8fc774b394c 100644 --- a/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/TitleSearch/titleSearchResult.hbs @@ -1,6 +1,6 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", "response": { "fromRecord": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs index b2f6d83534e..785daa1b983 100644 --- a/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateBlockListedWordDetails/updateblockListedWordDetailsResult.hbs @@ -1,11 +1,11 @@ { -"id":"string", -"version":"string", +"id":"$IGNORE$", +"version":"$IGNORE$", "responsetime":"$IGNORE$", -"metadata":null, +"metadata":"$IGNORE$", "response":{ "word":"{{word}}", "langCode":"{{langCode}}" }, -"errors":null +"errors":"$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs index dff8080f3a6..1382843c154 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceStatus/updateDeviceStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$, + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceType/updateDeviceTypeResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDeviceTypeStatus/updateteDeviceTypeStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDocCategory/updateDocCategoryResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs b/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateDocType/updateDocTypeResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateHolidayStatus/updateHolidayStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs b/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateIdSchema/updateIdSchemaResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs b/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateLanguage/updateLanguageResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateLocationStatus/updateLocationStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateMachineSpecificationStatus/updateteMachineSpecificationStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateMachineStatus/updateteMachineStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs index 54c0fab250c..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateMachineTypeStatus/updateteMachineTypeStatusResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, diff --git a/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegCenterTypeStatus/updateRegCenterTypeStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs index 2e68a3314b2..c7f78fc2d1c 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterLang/updateRegistrationCenterResult.hbs @@ -4,12 +4,12 @@ "responsetime": "$IGNORE$", "metadata": "$IGNORE$", "response": { - "isActive": $IGNORE$, + "isActive": "$IGNORE$", "createdBy": "$IGNORE$", "createdDateTime": "$IGNORE$", "updatedBy": "$IGNORE$", "updatedDateTime": "$IGNORE$", - "isDeleted": $IGNORE$, + "isDeleted": "$IGNORE$", "deletedDateTime": "$IGNORE$", "id": "{{id}}", "name": "{{name}}", @@ -24,7 +24,7 @@ "contactPhone": "$IGNORE$", "workingHours": "$IGNORE$", "langCode": "{{langCode}}", - "numberOfKiosks": $IGNORE$, + "numberOfKiosks": "$IGNORE$", "perKioskProcessTime": "$IGNORE$", "centerStartTime": "$IGNORE$", "centerEndTime": "$IGNORE$", diff --git a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs index 6af68241def..0bb6eb03d92 100644 --- a/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateRegistrationCenterNonLanguage/updateRegistrationCenterResult.hbs @@ -47,5 +47,5 @@ } ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateTemplateStatus/updateTemplateStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs b/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateUISpec/updateUISpecResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateUserCenterMappingStatus/updateUserCenterMappingStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs b/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs index dff8080f3a6..325f1e80e72 100644 --- a/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs +++ b/automationtests/src/main/resources/masterdata/UpdateZoneUserStatus/updateZoneUserStatusResult.hbs @@ -1,10 +1,10 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs index 0bb0240d6a1..9fdd9da5ba8 100644 --- a/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs +++ b/automationtests/src/main/resources/masterdata/UserCenterMapping/userCenterMappingResult.hbs @@ -14,5 +14,5 @@ "zoneName": "{{zoneName}}", "regCenterName": "{{regCenterName}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs index d9b7083a24c..4207ef08449 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocument/validDocumentResult.hbs @@ -7,5 +7,5 @@ "docTypeCode": "{{docTypeCode}}", "docCategoryCode": "{{docCategoryCode}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs index e1505f2346d..8f21fdb948a 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentFilter/validDocumentFilterResult.hbs @@ -1,8 +1,8 @@ { - "id": "string", - "version": "string", + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "filters": [ {{#each filters}} @@ -14,5 +14,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs index f118ca22593..d3369d3329c 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentMap/validDocumentMapResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}", "message": "{{message}}" diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs index f64fe30b50e..dc3f74eae34 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentSearch/validDocumentSearchResult.hbs @@ -32,5 +32,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } diff --git a/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs b/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs index f118ca22593..d3369d3329c 100644 --- a/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs +++ b/automationtests/src/main/resources/masterdata/ValidDocumentUnMap/validDocumentUnMapResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "status": "{{status}}", "message": "{{message}}" diff --git a/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs b/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs index 778c4dcc09e..7617d3c05e5 100644 --- a/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs +++ b/automationtests/src/main/resources/masterdata/ZoneUser/zoneUserResult.hbs @@ -7,5 +7,5 @@ "zoneCode": "{{zoneCode}}", "userId": "{{userId}}" }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file diff --git a/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs b/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs index 4852b9630eb..cb7b8b0b8f7 100644 --- a/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs +++ b/automationtests/src/main/resources/masterdata/getregistrationmachineusermappinghistory/getregistrationmachineusermappinghistoryResult.hbs @@ -1,8 +1,8 @@ { - "id": null, - "version": null, + "id": "$IGNORE$", + "version": "$IGNORE$", "responsetime": "$IGNORE$", - "metadata": null, + "metadata": "$IGNORE$", "response": { "registrationCenters": [ @@ -19,5 +19,5 @@ {{/each}} ] }, - "errors": null + "errors": "$IGNORE$" } \ No newline at end of file From d5d314598712de31da7cbf9ccf7e6ef1ef89c645 Mon Sep 17 00:00:00 2001 From: Nandhukumar Date: Wed, 23 Aug 2023 19:26:49 +0530 Subject: [PATCH 060/204] ES-247 --- .../apirig/admin/fw/util/AdminTestUtil.java | 202 +++++++++--------- .../fw/util/EncryptionDecrptionUtil.java | 8 +- .../authentication/fw/util/AuthTestsUtil.java | 16 +- .../fw/util/EncryptDecrptUtil.java | 8 +- .../authentication/fw/util/ReportUtil.java | 20 +- .../apirig/customReport/EmailableReport.java | 6 +- .../apirig/global/utils/GlobalMethods.java | 47 ++-- .../testrig/apirig/service/BaseTestCase.java | 6 +- .../GetWithParamForDownloadCard.java | 4 +- .../GetWithQueryParamForDownloadCard.java | 8 +- ...WithBodyWithOtpGenerateAndPdfDownload.java | 4 +- .../PostWithBodyWithPdfDownload.java | 4 +- .../mobileId/AddIdentity/AddIdentity.yml | 2 +- 13 files changed, 179 insertions(+), 156 deletions(-) diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java index 61f71e97e35..acb28dd52c6 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/AdminTestUtil.java @@ -349,7 +349,7 @@ protected Response postWithBodyAndCookie(String url, String jsonInput, boolean a token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { if (bothAccessAndIdToken) { response = RestClient.postRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, @@ -365,7 +365,7 @@ protected Response postWithBodyAndCookie(String url, String jsonInput, boolean a String dbChecker = GlobalConstants.TEST_FULLNAME + BaseTestCase.getLanguageList().get(0); checkDbAndValidate(timeStamp1, dbChecker); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -381,11 +381,11 @@ protected Response deleteWithBodyAndCookie(String url, String jsonInput, String url = uriKeyWordHandelerUri(url, testCaseName); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.deleteRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); } @@ -399,11 +399,11 @@ protected Response postWithBodyAndCookieWithText(String url, String jsonInput, S url = uriKeyWordHandelerUri(url, testCaseName); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, "*/*", cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -438,11 +438,11 @@ protected Response postRequestWithCookieAuthHeaderAndXsrfToken(String url, Strin headers.put(OAUTH_TRANSID_HEADERNAME, transactionId); token = properties.getProperty(GlobalConstants.XSRFTOKEN); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersAndCookies(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -468,11 +468,11 @@ protected Response postWithBodyAndCookieAuthHeaderAndXsrfTokenForAutoGeneratedId token = properties.getProperty(GlobalConstants.XSRFTOKEN); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersAndCookies(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); @@ -516,11 +516,11 @@ protected Response postRequestWithCookieAuthHeaderAndXsrfTokenForAutoGenId(Strin token = properties.getProperty(GlobalConstants.XSRFTOKEN); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersAndCookies(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -553,11 +553,11 @@ protected Response postRequestWithCookieAuthHeaderForAutoGenId(String url, Strin inputJson = smtpOtpHandler(inputJson, testCaseName); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersWithoutCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -626,11 +626,11 @@ protected Response postRequestWithCookieAuthHeader(String url, String jsonInput, } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersWithoutCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -645,11 +645,11 @@ protected Response postWithBodyAndCookieForKeyCloak(String url, String jsonInput url = uriKeyWordHandelerUri(url, testCaseName); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postRequestWithBearerToken(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -663,11 +663,11 @@ protected Response postWithBodyAcceptTextPlainAndCookie(String url, String jsonI String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.TEXT_PLAIN, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -686,11 +686,11 @@ protected Response postRequestWithCookieAuthHeaderAndSignature(String url, Strin headers.put(SIGNATURE_HEADERNAME, generateSignatureWithRequest(inputJson, partnerId)); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeaders(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -704,11 +704,11 @@ protected Response postRequestWithAuthHeaderAndSignatureForOtp(String url, Strin String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); url = uriKeyWordHandelerUri(url, testCaseName); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeaders(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -725,11 +725,11 @@ protected Response patchRequestWithCookieAuthHeaderAndSignature(String url, Stri headers.put(SIGNATURE_HEADERNAME, generateSignatureWithRequest(inputJson, null)); token = kernelAuthLib.getTokenByRole(role); logger.info("******Patch request Json to EndPointUrl: " + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.patchRequestWithMultipleHeaders(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -746,11 +746,11 @@ protected Response postRequestWithAuthHeaderAndSignature(String url, String json String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); headers.put(SIGNATURE_HEADERNAME, generateSignatureWithRequest(inputJson, partnerId)); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersWithoutCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -765,11 +765,11 @@ protected Response postRequestWithHeaderAndSignature(String url, String jsonInpu String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); headers.put(SIGNATURE_HEADERNAME, signature); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(headers.toString(), inputJson); try { response = RestClient.postRequestWithMultipleHeadersWithoutCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -799,7 +799,7 @@ protected Response postRequestWithCookieAndHeader(String url, String jsonInput, token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { if (bothAccessAndIdToken) { response = RestClient.postRequestWithCookieAndHeader(url, inputJson, MediaType.APPLICATION_JSON, @@ -809,7 +809,7 @@ protected Response postRequestWithCookieAndHeader(String url, String jsonInput, response = RestClient.postRequestWithCookieAndHeader(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, AUTHORIZATHION_HEADERNAME, AUTH_HEADER_VALUE); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -828,11 +828,11 @@ protected Response patchRequestWithCookieAndHeader(String url, String jsonInput, } token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.patchRequestWithCookieAndHeader(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, AUTHORIZATHION_HEADERNAME, AUTH_HEADER_VALUE); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -859,7 +859,7 @@ protected Response patchWithBodyAndCookie(String url, String jsonInput, String c token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { if (bothAccessAndIdToken) { response = RestClient.patchRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, @@ -868,7 +868,7 @@ protected Response patchWithBodyAndCookie(String url, String jsonInput, String c response = RestClient.patchRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -913,7 +913,7 @@ protected Response postWithBodyAndCookieForAutoGeneratedId(String url, String js token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { if (bothAccessAndIdToken) { response = RestClient.postRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, @@ -922,7 +922,7 @@ protected Response postWithBodyAndCookieForAutoGeneratedId(String url, String js response = RestClient.postRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (auditLogCheck) { JSONObject jsonObject = new JSONObject(inputJson); String timeStamp1 = jsonObject.getString(GlobalConstants.REQUESTTIME); @@ -949,11 +949,11 @@ protected Response postWithBodyAndBearerTokenForAutoGeneratedId(String url, Stri token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postRequestWithBearerToken(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); @@ -979,13 +979,13 @@ protected Response postWithBodyAndCookieForAutoGeneratedIdForUrlEncoded(String u } logger.info(GlobalConstants.POST_REQ_URL + url); logger.info(inputJson); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestAssured.given().contentType("application/x-www-form-urlencoded; charset=utf-8") .formParams(map).when().post(url); logger.info(response.getStatusCode()); logger.info(response.asString()); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); @@ -1016,11 +1016,11 @@ protected Response patchWithBodyAndCookieWithAutoGeneratedId(String url, String String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.patchRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -1037,11 +1037,11 @@ protected Response patchWithBodyAndCookieForAutoGeneratedId(String url, String j String inputJson = inputJsonKeyWordHandeler(jsonInput, testCaseName); token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.patchRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); @@ -1096,7 +1096,7 @@ protected Response getWithPathParamAndCookieForAutoGeneratedId(String url, Strin } logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (url.contains("{") || url.contains("?")) { if (bothAccessAndIdToken) { @@ -1121,7 +1121,7 @@ protected Response getWithPathParamAndCookieForAutoGeneratedId(String url, Strin if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (auditLogCheck) { JSONObject jsonObject = new JSONObject(jsonInput); @@ -1152,7 +1152,7 @@ protected Response getWithPathParamAndCookieForAutoGeneratedIdForKeyCloak(String token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (url.contains("{") || url.contains("?")) { response = RestClient.getRequestWithCookieAndPathParmForKeyCloak(url, map, MediaType.APPLICATION_JSON, @@ -1167,7 +1167,7 @@ protected Response getWithPathParamAndCookieForAutoGeneratedIdForKeyCloak(String writeAutoGeneratedIdForKeyCloak(response, idKeyName, testCaseName); } } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { @@ -1222,11 +1222,11 @@ protected Response postWithFormPathParamAndFile(String url, String jsonInput, St } token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postWithFormPathParamAndFile(url, formParams, pathParams, filetoUpload, fileKeyName, MediaType.MULTIPART_FORM_DATA, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); @@ -1275,7 +1275,7 @@ protected Response postWithParamAndFile(String url, String jsonInput, String rol token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(req.toString()); + GlobalMethods.reportRequest(null, req.toString()); try { if (bothAccessAndIdToken) { response = RestClient.postWithParamsAndFile(url, map, filetoUpload, fileKeyName, @@ -1284,7 +1284,7 @@ protected Response postWithParamAndFile(String url, String jsonInput, String rol response = RestClient.postWithParamsAndFile(url, map, filetoUpload, fileKeyName, MediaType.MULTIPART_FORM_DATA, token); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); @@ -1315,11 +1315,11 @@ protected Response postWithFormDataAndFile(String url, String jsonInput, String } token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postWithFormDataAndFile(url, formParams, absolueFilePath, MediaType.MULTIPART_FORM_DATA, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -1352,12 +1352,12 @@ else if (BaseTestCase.languageList.size() == 2) token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { response = RestClient.postWithMultipartFormDataAndFile(url, formParams, MediaType.MULTIPART_FORM_DATA, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -1409,11 +1409,11 @@ protected Response postWithFormDataAndMultipleFile(String url, String jsonInput, } token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postWithFormDataAndMultipleFile(url, formParams, listFiles, MediaType.MULTIPART_FORM_DATA, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -1469,7 +1469,7 @@ public static void initialUserCreation() { try { response = RestClient.postWithFormDataAndMultipleFile(url, formParams, listFiles, MediaType.MULTIPART_FORM_DATA, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1503,7 +1503,7 @@ protected Response putWithBodyAndCookie(String url, String jsonInput, String coo token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.PUT_REQ_STRING + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { if (bothAccessAndIdToken) { response = RestClient.putRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, @@ -1512,7 +1512,7 @@ protected Response putWithBodyAndCookie(String url, String jsonInput, String coo response = RestClient.putRequestWithCookie(url, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1534,11 +1534,11 @@ protected Response putWithPathParamAndCookie(String url, String jsonInput, Strin } token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.PUT_REQ_STRING + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.putRequestWithParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1560,11 +1560,11 @@ protected Response patchWithPathParamAndCookie(String url, String jsonInput, Str } token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.PUT_REQ_STRING + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.patchRequestWithParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1593,13 +1593,13 @@ protected Response putWithPathParamsBodyAndCookie(String url, String jsonInput, token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.PUT_REQ_STRING + url); - GlobalMethods.reportRequest(req.toString()); + GlobalMethods.reportRequest(null, req.toString()); try { if (testCaseName.toLowerCase().contains("dynamic")) pathParamsMap.put("id", idField); response = RestClient.putWithPathParamsBodyAndCookie(url, pathParamsMap, req.toString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1631,13 +1631,13 @@ protected Response putWithPathParamsBodyAndBearerToken(String url, String jsonIn token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.PUT_REQ_STRING + url); - GlobalMethods.reportRequest(req.toString()); + GlobalMethods.reportRequest(null, req.toString()); try { if (testCaseName.toLowerCase().contains("dynamic")) pathParamsMap.put("id", idField); response = RestClient.putWithPathParamsBodyAndBearerToken(url, pathParamsMap, req.toString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1663,11 +1663,11 @@ protected Response postWithPathParamsBodyAndCookie(String url, String jsonInput, token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postWithPathParamsBodyAndCookie(url, pathParamsMap, req.toString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1713,11 +1713,11 @@ protected Response postWithPathParamsBodyHeaderAndCookie(String url, String json token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(req.toString()); + GlobalMethods.reportRequest(headers.toString(), req.toString()); try { response = RestClient.postWithPathParamsBodyHeadersAndCookie(url, pathParamsMap, inputJson, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token, headers); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1743,11 +1743,11 @@ protected Response postWithQueryParamsBodyAndCookie(String url, String jsonInput token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.POST_REQ_URL + url); - GlobalMethods.reportRequest(inputJson); + GlobalMethods.reportRequest(null, inputJson); try { response = RestClient.postWithQueryParamsBodyAndCookie(url, queryParamsMap, req.toString(), MediaType.APPLICATION_JSON, "*/*", cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); if (testCaseName.toLowerCase().contains("_sid")) { writeAutoGeneratedId(response, idKeyName, testCaseName); } @@ -1775,11 +1775,11 @@ protected Response patchWithPathParamsBodyAndCookie(String url, String jsonInput token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.PUT_REQ_STRING + url); - GlobalMethods.reportRequest(req.toString()); + GlobalMethods.reportRequest(null, req.toString()); try { response = RestClient.patchWithPathParamsBodyAndCookie(url, pathParamsMap, req.toString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1832,7 +1832,7 @@ protected Response getWithPathParamAndCookie(String url, String jsonInput, boole token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (url.contains("{") || url.contains("?")) { if (bothAccessAndIdToken) { @@ -1867,7 +1867,7 @@ protected Response getWithPathParamAndCookie(String url, String jsonInput, boole checkDbAndValidate(timeStamp1, dbChecker); } } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -1900,7 +1900,7 @@ protected Response deleteWithPathParamAndCookie(String url, String jsonInput, St token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (bothAccessAndIdToken) { response = RestClient.deleteRequestWithCookieAndPathParm(url, map, MediaType.APPLICATION_JSON, @@ -1909,7 +1909,7 @@ protected Response deleteWithPathParamAndCookie(String url, String jsonInput, St response = RestClient.deleteRequestWithCookieAndPathParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { @@ -1934,12 +1934,12 @@ protected Response deleteWithPathParamAndCookieForKeyCloak(String url, String js token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { response = RestClient.deleteRequestWithCookieAndPathParmForKeyCloak(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { @@ -1984,7 +1984,7 @@ protected byte[] getWithPathParamAndCookieForPdf(String url, String jsonInput, b token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (bothAccessAndIdToken) { @@ -2027,7 +2027,7 @@ protected byte[] postWithBodyAndCookieForPdf(String url, String jsonInput, Strin token = kernelAuthLib.getTokenByRole(role); } logger.info("******post request to EndPointUrl: " + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (bothAccessAndIdToken) { pdf = RestClient.postWithBodyForPdf(url, jsonInput, MediaType.APPLICATION_JSON, @@ -2068,7 +2068,7 @@ protected byte[] getWithQueryParamAndCookieForPdf(String url, String jsonInput, token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (bothAccessAndIdToken) { pdf = RestClient.getPdfWithQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, @@ -2100,11 +2100,11 @@ protected Response getWithQueryParamAndCookie(String url, String jsonInput, Stri token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { response = RestClient.getRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); @@ -2127,11 +2127,11 @@ protected Response patchWithQueryParamAndCookie(String url, String jsonInput, St token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { response = RestClient.patchRequestWithCookieAndQueryParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e.getMessage()); @@ -3425,7 +3425,7 @@ protected Response postWithOnlyPathParamAndCookie(String url, String jsonInput, token = kernelAuthLib.getTokenByRole(role); } logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { if (bothAccessAndIdToken) { response = RestClient.postRequestWithCookieAndOnlyPathParm(url, map, MediaType.APPLICATION_JSON, @@ -3434,7 +3434,7 @@ protected Response postWithOnlyPathParamAndCookie(String url, String jsonInput, response = RestClient.postRequestWithCookieAndOnlyPathParm(url, map, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, cookieName, token); } - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); return response; } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); @@ -3457,10 +3457,10 @@ protected Response postWithOnlyQueryParamAndCookie(String url, String jsonInput, token = kernelAuthLib.getTokenByRole(role); logger.info(GlobalConstants.GET_REQ_STRING + url); - GlobalMethods.reportRequest(jsonInput); + GlobalMethods.reportRequest(null, jsonInput); try { response = RestClient.postRequestWithQueryParm(url, map, "*/*", "*/*", cookieName, token); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); } catch (Exception e) { logger.error(GlobalConstants.EXCEPTION_STRING_2 + e); } @@ -4569,7 +4569,7 @@ public static int getOtpExpTimeFromActuator() { String url = ApplnURI + propsKernel.getProperty("actuatorIDAEndpoint"); try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new org.json.JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4601,7 +4601,7 @@ public static String getValueFromActuator(String section, String key) { String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4633,7 +4633,7 @@ public static String getValueFromEsignetActuator(String section, String key) { String value = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4664,7 +4664,7 @@ public static String getValueFromConfigActuator() { String claims = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); @@ -4697,7 +4697,7 @@ public static String getRegprocWaitFromActuator() { String waitInterval = null; try { response = RestClient.getRequest(url, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON); - GlobalMethods.reportResponse(url, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), url, response); responseJson = new JSONObject(response.getBody().asString()); responseArray = responseJson.getJSONArray("propertySources"); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java index 5a8c5cfd765..6eb6ce32132 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/admin/fw/util/EncryptionDecrptionUtil.java @@ -83,7 +83,7 @@ public Map getEncryptSessionKeyValue(String jsonString) { String json = getEncryption(jsonString); JSONObject jsonobj = new JSONObject(json); Reporter.log(" Encryption of identity request "); - GlobalMethods.reportRequest(json); + GlobalMethods.reportRequest(null, json); ecryptData.put("key", jsonobj.get(key).toString()); ecryptData.put("data", jsonobj.get(data).toString()); ecryptData.put("hmac", jsonobj.get(hmac).toString()); @@ -107,7 +107,7 @@ public Map getInternalEncryptSessionKeyValue(String jsonString) String json = getIntenalEncryption(jsonString); JSONObject jsonobj = new JSONObject(json); Reporter.log(" Encryption of identity request "); - GlobalMethods.reportRequest(json); + GlobalMethods.reportRequest(null, json); ecryptData.put("key", jsonobj.get(key).toString()); ecryptData.put("data", jsonobj.get(data).toString()); ecryptData.put("hmac", jsonobj.get(hmac).toString()); @@ -129,7 +129,7 @@ private String getEncryption(String jsonString) { try { JSONObject objectData = new JSONObject(jsonString); Reporter.log(" Identity request:"); - GlobalMethods.reportRequest(objectData.toString()); + GlobalMethods.reportRequest(null, objectData.toString()); return RestClient.postRequest(EncryptUtilBaseUrl+properties.get("encryptionPath"), objectData.toString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON).asString(); } catch (Exception e) { @@ -148,7 +148,7 @@ private String getIntenalEncryption(String jsonString) { try { JSONObject objectData = new JSONObject(jsonString); Reporter.log(" Identity request:"); - GlobalMethods.reportRequest(objectData.toString()); + GlobalMethods.reportRequest(null, objectData.toString()); return RestClient.postRequest(EncryptUtilBaseUrl+properties.get("internalEncryptionPath"), objectData.toString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON).asString(); } catch (Exception e) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java index 2a3bea66edd..c83f0cda37e 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/AuthTestsUtil.java @@ -147,7 +147,7 @@ protected boolean postRequestAndGenerateOuputFile(File[] listOfFiles, String url responseJson = response.asString(); responseJsonToVerifyDigtalSignature = responseJson; responseDigitalSignatureValue = response.getHeader(responseDigitalSignatureKey); - GlobalMethods.reportResponse(urlPath, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), urlPath, response); responseJson = JsonPrecondtion.toPrettyFormat(responseJson); outputStream.write(responseJson.getBytes()); } catch (Exception e) { @@ -187,7 +187,7 @@ protected boolean postRequestAndGenerateOuputFileForIntenalAuth(File[] listOfFil cookieName, cookieValue, AUTHORIZATHION_COOKIENAME, authHeaderValue); responseJsonToVerifyDigtalSignature = response.asString(); responseDigitalSignatureValue = response.getHeader(responseDigitalSignatureKey); - GlobalMethods.reportResponse(urlPath, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), urlPath, response); outputStream.write(response.asString().getBytes()); } catch (Exception e) { bReturn = false; @@ -224,7 +224,7 @@ protected String postRequestAndGenerateOuputFileWithResponse(File[] listOfFiles, else responseJson = postRequestWithCookie(listOfFiles[j].getAbsolutePath(), urlPath, code, cookieName, cookieValue); - GlobalMethods.reportResponse(urlPath, responseJson); + GlobalMethods.reportResponse(responseJson.getHeaders().asList().toString(), urlPath, responseJson); outputStream.write(responseJson.asString().getBytes()); return responseJson.asString(); } @@ -307,7 +307,7 @@ protected boolean postRequestAndGenerateOuputFileForUINGeneration(File[] listOfF if (responseJson.asString().contains("Invalid UIN")) { return false; } else { - GlobalMethods.reportResponse(urlPath, responseJson); + GlobalMethods.reportResponse(responseJson.getHeaders().asList().toString(), urlPath, responseJson); outputStream.write(responseJson.asString().getBytes()); return true; } @@ -584,7 +584,7 @@ protected void displayContentInFile(File[] listOfFiles, String keywordToFind) { for (int j = 0; j < listOfFiles.length; j++) { if (listOfFiles[j].getName().contains(keywordToFind)) { String responseJson = getContentFromFile(listOfFiles[j]); - GlobalMethods.reportRequest(responseJson); + GlobalMethods.reportRequest(null, responseJson); } } } catch (Exception e) { @@ -1333,7 +1333,7 @@ protected String getRequestAndGenerateOuputFileWithResponse(String parentFile, S try { outputStream = new FileOutputStream(parentFile + "/" + generateOutputFileKeyword + ".json"); String responseJson = getResponseWithCookie(urlPath, cookieName, cookieValue); - GlobalMethods.reportResponse(urlPath, responseJson, true); + GlobalMethods.reportResponse(null, urlPath, responseJson, true); outputStream.write(responseJson.getBytes()); return responseJson; } catch (Exception e) { @@ -1422,7 +1422,7 @@ protected boolean patchRequestAndGenerateOuputFileForIntenalAuth(File[] listOfFi cookieValue); responseJsonToVerifyDigtalSignature = response.asString(); responseDigitalSignatureValue = response.getHeader(responseDigitalSignatureKey); - GlobalMethods.reportResponse(urlPath, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), urlPath, response); outputStream.write(response.asString().getBytes()); } catch (Exception e) { bReturn = false; @@ -1450,7 +1450,7 @@ protected Response postRequestAndGenerateOuputFileAndReturnResponse(File[] listO cookieValue); responseJsonToVerifyDigtalSignature = response.asString(); responseDigitalSignatureValue = response.getHeader(responseDigitalSignatureKey); - GlobalMethods.reportResponse(urlPath, response); + GlobalMethods.reportResponse(response.getHeaders().asList().toString(), urlPath, response); outputStream.write(response.asString().getBytes()); } catch (Exception e) { IDASCRIPT_LOGGER.error(GlobalConstants.EXCEPTION_STRING_2 + e); diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/EncryptDecrptUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/EncryptDecrptUtil.java index 6196d1e8f23..c9d38fef2d1 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/EncryptDecrptUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/EncryptDecrptUtil.java @@ -43,7 +43,7 @@ public static Map getEncryptSessionKeyValue(String filename) { JSONParser parser = new JSONParser(); JSONObject jsonobj = (JSONObject) parser.parse(json); Reporter.log(" Encryption of identity request "); - GlobalMethods.reportRequest(json); + GlobalMethods.reportRequest(null, json); ecryptData.put("key", jsonobj.get(key).toString()); ecryptData.put("data", jsonobj.get(data).toString()); ecryptData.put("hmac", jsonobj.get(hmac).toString()); @@ -67,7 +67,7 @@ public static Map getInternalEncryptSessionKeyValue(String filen JSONParser parser = new JSONParser(); JSONObject jsonobj = (JSONObject) parser.parse(json); Reporter.log(" Encryption of identity request "); - GlobalMethods.reportRequest(json); + GlobalMethods.reportRequest(null, json); ecryptData.put("key", jsonobj.get(key).toString()); ecryptData.put("data", jsonobj.get(data).toString()); ecryptData.put("hmac", jsonobj.get(hmac).toString()); @@ -88,7 +88,7 @@ private static String getEncryption(String filename) { try { JSONObject objectData = (JSONObject) new JSONParser().parse(new FileReader(filename)); Reporter.log(" Identity request:"); - GlobalMethods.reportRequest(objectData.toString()); + GlobalMethods.reportRequest(null, objectData.toString()); return RestClient.postRequest(RunConfigUtil.objRunConfig.getEncryptUtilBaseUrl()+RunConfigUtil.objRunConfig.getEncryptionPath(), objectData.toJSONString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON).asString(); } catch (Exception e) { @@ -107,7 +107,7 @@ private static String getIntenalEncryption(String filename) { try { JSONObject objectData = (JSONObject) new JSONParser().parse(new FileReader(filename)); Reporter.log(" Identity request:"); - GlobalMethods.reportRequest(objectData.toString()); + GlobalMethods.reportRequest(null, objectData.toString()); return RestClient.postRequest(RunConfigUtil.objRunConfig.getEncryptUtilBaseUrl()+RunConfigUtil.objRunConfig.getInternalEncryptionPath(), objectData.toJSONString(), MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON).asString(); } catch (Exception e) { diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java index ce4f81055a9..b44be38b991 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/authentication/fw/util/ReportUtil.java @@ -18,6 +18,22 @@ */ public class ReportUtil { + /** + * Publish the request and response headers in text area + * @param content + * @return test area html + */ + public static String getTextAreaForHeaders(String headers) { + String formattedHeader = "No headers"; + if (headers != null) + formattedHeader = headers; + StringBuilder sb = new StringBuilder(); + sb.append("
"); + return sb.toString(); + } + /** * Method to show the output validation result in table format in testng report * @@ -73,9 +89,9 @@ public static String getOutputValidationReport(Map"); + sb.append("
"); + sb.append("
"); return sb.toString(); } } diff --git a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java index c5e680b6fe8..1ba720c1715 100644 --- a/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java +++ b/automationtests/src/main/java/io/mosip/testrig/apirig/customReport/EmailableReport.java @@ -458,14 +458,14 @@ private void writeScenario(int scenarioIndex, String label, ITestResult result) if (parameterCount > 0) { writer.print("
Parameter #"); - writer.print(i); + writer.print("Testcase Input"); writer.print("
"); - writer.print(Utils.escapeHtml(Utils.toString(parameter))); + writer.print(Utils.escapeHtml(testcaseDTO.substring(0, testcaseDTO.length()-1))); writer.print("
Testcase Input"); - writer.print("
"); - writer.print(Utils.escapeHtml(testcaseDTO.substring(0, testcaseDTO.length()-1))); - writer.print("
Testcase Input"); + writer.print("
"); + writer.print(Utils.escapeHtml(testcaseDTO.substring(0, testcaseDTO.length()-1))); + writer.print("