REST- അഷ്വേർഡിൽ എഴുതിയ എപി ടെസ്റ്റുകൾക്ക് മുകളിൽ ഒരു കുക്കുമ്പർ ലെയർ എങ്ങനെ ചേർക്കാമെന്നതിനെക്കുറിച്ചുള്ള ഘട്ടം ഘട്ടമായുള്ള ഗൈഡ് ഈ പോസ്റ്റ് നൽകുന്നു.
റെസ്റ്റ്-അഷ്വേർഡിന്റെ ഡിഎസ്എൽ ഇതിനകം തന്നെ ബിഡിഡി-ശൈലിയിലുള്ള ടെസ്റ്റുകൾ എഴുത്ത്-എപ്പോൾ-പിന്നെ ഫോർമാറ്റിൽ നൽകുന്നു, പക്ഷേ അത് ഇപ്പോഴും കോഡിൽ മറച്ചിരിക്കുന്നു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഏതൊക്കെ രംഗങ്ങൾ ഉൾക്കൊള്ളുന്നുവെന്ന് കാണണമെങ്കിൽ, നിങ്ങൾ ഇപ്പോഴും എപിഐ ടെസ്റ്റുകൾ പരിശോധിച്ച് കോഡ് വായിക്കണം. സവിശേഷത ഫയലുകളൊന്നുമില്ല.
കുക്കുമ്പർ, ഫീച്ചർ ഫയലുകൾ എന്നിവ ചേർത്ത് നിലവിലുള്ള REST- അഷ്വേർഡ് എപി ടെസ്റ്റുകൾ റിഫാക്റ്റർ ചെയ്യുക എന്നതാണ് ഈ പോസ്റ്റിന്റെ ലക്ഷ്യം, അതിനാൽ അടിസ്ഥാന കോഡിലേക്ക് നോക്കാതെ തന്നെ സാഹചര്യങ്ങൾ കൂടുതൽ വ്യക്തമായി വായിക്കാൻ കഴിയും.
ഈ ഉദാഹരണത്തിൽ, ഉപയോക്തൃ സൃഷ്ടിക്കൽ API പരിശോധിക്കുന്നതിന് ഞങ്ങൾ കോഡ് എഴുതുന്നു.
ആദ്യം, ഞങ്ങൾക്ക് ഒരു റെസ്റ്റ്-അഷ്വേർഡ്, ജുനിറ്റ് ടെസ്റ്റ് ഉണ്ട്, അതിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:
src/test/java/io.devqa/scenarios
import io.restassured.RestAssured; import io.restassured.http.ContentType; import io.restassured.response.Response; import org.junit.jupiter.api.*; import static io.restassured.RestAssured.given; public class UserTests {
private static String path;
private static String validRequest = '{
' +
' 'username': 'test-api-user',
' +
' 'email': 'test-api-user@email.com',
' +
' 'password': 'Passw0rd123!',
' +
' 'name': 'Test Api-User'
}';
@BeforeAll
public static void setConfig() {
RestAssured.baseURI = 'https://localhost:8080';
path = '/users';
}
@Test
public void shouldBeAbleToCreateNewUser() {
Response createUser = given()
.auth()
.preemptive()
.basic('MY_USERNAME', 'MY_PASSWORD')
.header('Accept', ContentType.JSON.getAcceptHeader())
.contentType(ContentType.JSON)
.body(validRequest)
.post(path)
.then().extract().response();
Assertions.assertEquals(201, createUser.getStatusCode());
String username = createUser.jsonPath().get('username');
String email = createUser.jsonPath().get('email');
String name = createUser.jsonPath().get('name');
String id = createUser.jsonPath().get('id');
Assertions.assertEquals('test-api-user', username);
Assertions.assertEquals('test-api-user@email.com', email);
Assertions.assertEquals('Test Api-User', name);
Assertions.assertNotNull(id);
} }
മുകളിലുള്ള ടെസ്റ്റ് ക്ലാസ്സിൽ നിന്ന് നേരിട്ട് പ്രവർത്തിപ്പിക്കാൻ കഴിയും, കാരണം ഇത് ജുനിറ്റിന് അഭ്യർത്ഥിക്കാൻ കഴിയും.
ദി setConfig()
രീതി മുൻവ്യവസ്ഥയെ സജ്ജമാക്കുന്നു. പരീക്ഷണ രീതി പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു (അഭ്യർത്ഥന അയയ്ക്കുന്നു) തുടർന്ന് പ്രതികരണ കോഡും പ്രതികരണ പേലോഡും ഉറപ്പിക്കുന്നു.
അടുത്തതായി, മുകളിലുള്ള REST- അഷ്വേർഡ് എപി ടെസ്റ്റിന് മുകളിൽ കുക്കുമ്പർ ലെയർ എങ്ങനെ ഇടാമെന്ന് നോക്കാം.
ആദ്യം ചെയ്യേണ്ടത് ഞങ്ങളുടെ പ്രോജക്റ്റിൽ കുക്കുമ്പർ ഡിപൻഡൻസി ചേർക്കുക എന്നതാണ്.
ഞങ്ങളുടെ build.gradle
ൽ ഗ്രേഡിൽ ഉപയോഗിക്കുന്നു ഫയൽ, ഞങ്ങൾ ഇവ | _ + + | |
dependencies
ഇവ dependencies {
ൽ
testCompile 'io.cucumber:cucumber-java:6.2.2'
testCompile 'io.cucumber:cucumber-junit:6.2.2'
testCompile 'io.rest-assured:rest-assured:3.3.0'
testCompile 'com.jayway.jsonpath:json-path:2.4.0' } configuration
ഫയൽ:
build.gradle
configurations {
എന്നതിലും ഒരു ടാസ്ക് സൃഷ്ടിക്കേണ്ടതുണ്ട് സാഹചര്യങ്ങൾ ഉൾക്കൊള്ളുന്ന കുക്കുമ്പർ സവിശേഷത ഫയലുകൾ പ്രവർത്തിപ്പിക്കാനുള്ള ഫയൽ:
cucumberRuntime {
extendsFrom testImplementation
} }
build.gradle
കുക്കുമ്പറിനായുള്ള മാറ്റങ്ങൾ ഉൾക്കൊള്ളുന്നതിനായി ഞങ്ങളുടെ പ്രോജക്റ്റ് ഘടനയിൽ മാറ്റം വരുത്തേണ്ടതുണ്ട്.
സവിശേഷത ഫയലുകൾ ഇതിൽ സംരക്ഷിക്കും:
task cucumber() {
dependsOn assemble, compileTestJava
doLast {
mkdir 'build/test-results/'
javaexec {
main = 'io.cucumber.core.cli.Main'
classpath = configurations.cucumberRuntime + sourceSets.main.output + sourceSets.test.output
args = ['--plugin', 'pretty', '--plugin', 'html:build/test-results/functional.html', '--plugin', 'junit:build/test-results/functional.xml','--tags', '@functional', '--glue', 'scenarios', 'src/test/resources']
}
} }
ഘട്ടം നിർവ്വചനങ്ങൾ സംരക്ഷിക്കും
src/test/resources/scenarios
അടുത്തതായി, src/test/java/scenarios
എന്ന ഒരു സവിശേഷത ഫയൽ ഞങ്ങൾ സൃഷ്ടിക്കും UserScenarios.feature
ഫോൾഡർ.
സവിശേഷത ഫയൽ ഇങ്ങനെയായിരിക്കും:
src/test/resources/scenarios
ഞങ്ങളുടെ ഫീച്ചർ ഫയലിലെ സ്റ്റേറ്റ്മെന്റുകളിൽ ഒട്ടിക്കാൻ കഴിയുന്ന സ്റ്റെപ്പ് ഡെഫനിഷനുകൾ എഴുതുന്നതിന് ഇപ്പോൾ ഞങ്ങളുടെ REST- ഉറപ്പുള്ള ജുനിറ്റ് പരിശോധന പൊളിക്കേണ്ടതുണ്ട്.
@functional Feature: User Scenarios Scenario: I should be able to create a new user
Given the users endpoint exists
When I send a valid create user payload
Then response status code should be 201
And create user response should be valid
മുകളിലുള്ള സ്റ്റെപ്പ് നിർവ്വചനങ്ങളിൽ കാണുന്നത് പോലെ, ഫീച്ചർ ഫയലിലെ സാഹചര്യത്തിലെ ഓരോ വരിയിലും, ഞങ്ങൾക്ക് അനുബന്ധമായ സ്റ്റെപ്പ് ഡെഫനിഷൻ ഉണ്ട്.
import io.cucumber.java.en.And; import io.cucumber.java.en.Given; import io.cucumber.java.en.Then; import io.cucumber.java.en.When; import io.restassured.RestAssured; import io.restassured.http.ContentType; import io.restassured.response.Response; import org.junit.jupiter.api.Assertions; import static io.restassured.RestAssured.given; public class UserScenarios {
ഉള്ള രീതി വ്യാഖ്യാനം പ്രീ-ആവശ്യകതകൾ സജ്ജമാക്കുന്നു.
private String path;
private Response response;
private String validRequest = '{
' +
' 'username': 'test-api-user',
' +
' 'email': 'test-api-user@email.com',
' +
' 'password': 'Passw0rd123!',
' +
' 'name': 'Test Api-User'
}';
@Given('the users endpoint exists')
public void preReq() {
RestAssured.baseURI = 'https://localhost:8080';
path = '/users';
}
@When('I send a valid create user payload')
public void createUser() {
response = given()
.auth()
.preemptive()
.basic('MY_USERNAME', 'MY_PASSWORD')
.header('Accept', ContentType.JSON.getAcceptHeader())
.contentType(ContentType.JSON)
.body(validRequest)
.post(path)
.then().extract().response();
}
@Then('response status code should be {int}')
public void checkResponseStatusCode(int code) {
Assertions.assertEquals(code, response.getStatusCode());
}
@And('create user response should be valid')
public void verifyResponse() {
String username = response.jsonPath().get('username');
String email = response.jsonPath().get('email');
String name = response.jsonPath().get('name');
String id = response.jsonPath().get('id');
Assertions.assertEquals('test-api-user', username);
Assertions.assertEquals('test-api-user@email.com', email);
Assertions.assertEquals('Test Api-User', name);
Assertions.assertNotNull(id);
} } Given
ഉള്ള രീതി വ്യാഖ്യാനം അഭ്യർത്ഥന അയയ്ക്കുന്ന പ്രവർത്തനവും ഒടുവിൽ When
ഉപയോഗിച്ചുള്ള രീതിയും ചെയ്യുന്നു വ്യാഖ്യാനം പ്രതികരണത്തെക്കുറിച്ചുള്ള അവകാശവാദങ്ങൾ നിർവ്വഹിക്കുന്നു.
മുകളിൽ പറഞ്ഞവ നടപ്പിലാക്കാൻ, നമ്മൾ ചെയ്യേണ്ടത് Then
എന്ന കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുക മാത്രമാണ് പ്രോജക്റ്റ് റൂട്ടിൽ നിന്നുള്ള ഒരു ടെർമിനലിൽ.
പരിശോധനകൾ നടന്നുകഴിഞ്ഞാൽ, ഫലങ്ങൾ ./gradle cucumber
ഈ പോസ്റ്റിൽ, REST ഉറപ്പുള്ള API ടെസ്റ്റുകൾക്ക് മുകളിൽ ഒരു കുക്കുമ്പർ ലെയർ എങ്ങനെ ചേർക്കാമെന്നതിനെക്കുറിച്ചുള്ള ഒരു ഘട്ടം ഘട്ടമായുള്ള ഗൈഡ് ഞങ്ങൾ ഉൾപ്പെടുത്തി. അങ്ങനെ ചെയ്യുന്നതിലൂടെ, ഞങ്ങളുടെ സാഹചര്യങ്ങൾ സവിശേഷത ഫയലുകളിൽ എഴുതാൻ കഴിയും, അത് സാങ്കേതികേതര ആളുകൾക്ക് കൂടുതൽ വായിക്കാൻ കഴിയും.