cucumber.api.java.en.Then Java Examples

@Then("I have (\\d) items? in my cart")
public void one_item_in_cart(Integer items) {
    String expected_items = items.toString();

    By itemsInCart = By.className("shopping_cart_badge");

    wait.until(ExpectedConditions.elementToBeClickable(getDriver().findElement(itemsInCart)));
    Assert.assertEquals(getDriver().findElement(itemsInCart).getText(), expected_items);
}
 

@Then("^he should see the total cost including shipping:$")
public void he_should_see_the_total_cost_including_shipping(DataTable arg1) {
    theActorInTheSpotlight().attemptsTo(ProceedToCheckOut.fromCartSummaryPopup());
    theActorInTheSpotlight().attemptsTo(ProceedToCheckOut.fromCheckoutSummary());
    theActorInTheSpotlight().should(
            seeThat(Checkout.totalPrice(), containsString(arg1.raw().get(1).get(2)))
    );
}
 

@Then("^s?he should see the list of (.*) with prices available for sale$")
public void she_should_see_the_list_of_items_with_prices_available_for_sale(List<String> items)  {
    theActorInTheSpotlight().should(
            seeThat(SearchResults.resultsGrid(), is(Available)),
            seeThat(SearchResults.checkForTitle(), containsString("product")),
            seeThat(SearchResults.price(), is(Available))
    );
}
 

@Then("^verify: \\$\\{([^\"]*)}!=\"([^\"]*)\"$")
public void verifyVariableNotEqualsString(String expression, String expected) {
    assertThat(variables.get(expression), not(expressions.evaluate(expected)));
}
 

@Then("^verify: '([^\"]*)'=float: (\\d+\\.\\d+)$")
public void verifyEqualsFloat(String path, String expected) throws Throwable {
    assertThat(actual.json(path), is(parseFloat(expected)));
}
 

@Then("^verify: '([^\"]*)'>long: ([^\"]*)$")
public void verifyGreaterThanLong(String path, String expected) throws Throwable {
    assertThat((Long) actual.json(path), greaterThan(parseLong(expected)));
}
 

@Then("^verify: \\$\\{([^\"]*)}!=decimal: ([^\"]*)$")
public void verifyVariableNotEqualsDecimal(String expression, String expected) {
    assertNotEquals(0, ((BigDecimal) variables.get(expression)).compareTo(new BigDecimal(expected)));
}
 

@Then("^return a (\\d+) not found status$")
public void return_a_status(int status) throws Throwable {
	Assert.assertEquals(HttpStatus.NOT_FOUND, errResponse.getStatusCode());
}
 

@Then("^verify: \\$\\{([^\"]*)}>=float: (\\d+\\.\\d+)$")
public void verifyVariableGreaterThanOrEqualToFloat(String expression, String expected) {
    assertThat((Float) variables.get(expression), greaterThanOrEqualTo(parseFloat(expected)));
}
 

@Then("^verify: '([^\"]*)'<=(\\d+)$")
public void verifyLessThanOrEqualToInteger(String path, final int expected) throws Throwable {
    assertThat((int) actual.json(path), lessThanOrEqualTo(expected));
}
 

@Then("^return error message \"(.*)\"$")
public void return_error_message_indicating_product_is_not_found(String errMsg) throws Throwable {
	Assert.assertTrue(errResponse.getBody().contains(errMsg));
}
 

@Then("^verify: '([^\"]*)' length: (\\d+)$")
public void verifyStringLength(String path, int length) throws Throwable {
    assertThat(String.valueOf(toBeVerified.json(path)).length(), is(length));
}
 

@Then("^verify: '([^\"]*)' matches: '([^\"]*)'$")
public void verifyMatchesRegex(String path, String regex) throws Throwable {
    assertTrue(String.valueOf(toBeVerified.json(path)).matches(regex));
}
 

@Then("^return a (\\d+) not found status$")
public void return_a_status(int status) throws Throwable {
	Assert.assertEquals(HttpStatus.NOT_FOUND, errResponse.getStatusCode());
}
 

@Then("^verify: \\$\\{([^\"]*)}=float: (\\d+\\.\\d+)$")
public void verifyVariableEqualsFloat(String expression, String expected) {
    assertThat(variables.get(expression), is(parseFloat(expected)));
}
 

@Then("^return error message \"(.*)\"$")
public void return_error_message_indicating_product_is_not_found(String errMsg) throws Throwable {
	Assert.assertTrue(errResponse.getBody().contains(errMsg));
}
 

@Then("^verify: \\$\\{([^\"]*)}>=decimal: ([^\"]*)$")
public void verifyVariableGreaterThanOrEqualToDecimal(String expression, String expected) {
    assertTrue(((BigDecimal) this.variables.get(expression)).compareTo(new BigDecimal(expected)) >= 0);
}
 

@Then("^verify: \\$\\{([^\"]*)}!=code:$")
public void verifyVariableNotEqualsCodeBlock(String expression, String code) throws ScriptException {
    assertThat(variables.get(expression), not(eval(expressions.evaluate(code))));
}
 

@Then("^verify: '([^\"]*)'=double: (\\d+\\.\\d+)$")
public void verifyEqualsDouble(String path, String expected) throws Throwable {
    assertThat(actual.json(path), is(parseDouble(expected)));
}
 

@Then("^verify: '([^\"]*)'>decimal: ([^\"]*)$")
public void verifyGreaterThanDecimal(String path, String expected) throws Throwable {
    assertEquals(1, ((BigDecimal) actual.json(path)).compareTo(new BigDecimal(expected)));
}
 

@Then("^verify: \\$\\{([^\"]*)} ends with: '([^\"]*)'$")
public void verifyVariableEndsWithLiteral(String expression, String prefix) {
    assertThat(String.valueOf(variables.get(expression)), endsWith(prefix));
}
 

@Then("^verify: \\$\\{([^\"]*)}=(true|false)$")
public void verifyVariableEqualsBoolean(String expression, String expected) {
    assertThat(variables.get(expression), is(Boolean.valueOf(expected)));
}
 

@Then("^response header: '([^\"]*)'='([^\"]*)'$")
public void verifyResponseHeader(String key, String expected) {
    List<String> values = context.responseHeader(key);
    assertNotNull(values);
    assertThat(join(",", values), is(expected));
}
 

@Then("^response body: ([^\"]*)$")
public void verifyResponseBodyAgainstFile(String file) throws IOException {
    String content = expressions.evaluate(read(configuration.classpathFile(file)));
    assertThat(context.responseBody(), is(content));
}
 

@Then("^print: \"([^\"]*)\"$")
public void printExpression(String printing) {
    System.out.println(expressions.evaluate(printing));
}
 

@Then("^verify: \\$\\{([^\"]*)} contains json: ([^\"]*)$")
public void variableContainsJsonFromFile(String expression, String fileName) throws IOException {
    assertThat(variables.get(expression), jsonEquals(fileContent(fileName))
            .when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_EXTRA_FIELDS));
}
 

@Then("^the page title contains (.*)$")
@org.jbehave.core.annotations.Then("the page title contains $title")
public void pageTitleIs(String title) {
    assertThat(title(), containsString(title));
}
 

@Then("^verify: \\$\\{([^\"]*)} has size: (\\d+)$")
public void variableHasSize(String expression, Integer size) {
    assertThat(size(variables.get(expression)), is(size));
}
 

@Then("^verify: \\$\\{([^\"]*)}!=code file: ([^\"]*)$")
public void verifyVariableNotEqualsInFile(String expression, String file) throws IOException, ScriptException {
    assertThat(variables.get(expression), not(eval(expressions.evaluate(read(configuration.classpathFile(file))))));
}
 

@Then("^verify: \\$\\{([^\"]*)}!=float: (\\d+\\.\\d+)$")
public void verifyVariableNotEqualsFloat(String expression, String expected) {
    assertThat(variables.get(expression), not(parseFloat(expected)));
}