package org.jbehave.examples.core.steps;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.jbehave.core.annotations.Alias;
import org.jbehave.core.annotations.Aliases;
import org.jbehave.core.annotations.AsParameterConverter;
import org.jbehave.core.annotations.Given;
import org.jbehave.core.annotations.Named;
import org.jbehave.core.annotations.Then;
import org.jbehave.core.annotations.When;
import org.jbehave.core.model.ExamplesTable;
import org.jbehave.core.model.OutcomesTable;
import org.jbehave.core.steps.CandidateSteps;
import org.jbehave.core.steps.InstanceStepsFactory;
import org.jbehave.core.steps.Parameters;
import org.jbehave.examples.core.CoreStory;
import org.jbehave.examples.core.model.Stock;
import org.jbehave.examples.core.model.Stock.AlertStatus;
import org.jbehave.examples.core.model.Trader;
import org.jbehave.examples.core.persistence.TraderPersister;
import org.jbehave.examples.core.service.TradingService;
import static java.util.Arrays.asList;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
/**
* POJO holding the candidate steps for the trader example.
* The {@link CandidateSteps} instance wrapping this are created via the {@link InstanceStepsFactory}
* in the {@link CoreStory}.
*/
public class TraderSteps {
private TradingService service;
private Stock stock;
private Trader trader;
private List<Trader> traders = new ArrayList<Trader>();
private List<Trader> searchedTraders;
private Date date;
private ExamplesTable ranksTable;
private String stockExchange;
private String assetClass;
private TradeType tradeType;
public TraderSteps() {
this(new TradingService());
}
public TraderSteps(TradingService service) {
this.service = service;
}
public TradingService getService() {
return this.service;
}
@Given("a date of %date")
public void aDate(Date date) {
this.date = date;
}
@When("%days days pass")
public void daysPass(int days) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_YEAR, days);
date = calendar.getTime();
}
@Then("the date is %date")
public void theDate(Date date) {
assertThat(date, equalTo(this.date));
}
@Given("a trader of {name|id} %trader")
public void aTrader(Trader trader) {
this.trader = trader;
}
@Given("the trader ranks: %ranksTable")
@Alias("the traders: %ranksTable")
public void theTraderRanks(ExamplesTable ranksTable) {
this.ranksTable = ranksTable;
traders.clear();
traders.addAll(toTraders(ranksTable));
}
@When("traders are subset to \"%regex\" by name")
@Alias("traders are filtered by \"%regex\"")
public void subsetTradersByName(String regex) {
searchedTraders = new ArrayList<Trader>();
for (Trader trader : traders) {
if (trader.getName().matches(regex)) {
searchedTraders.add(trader);
}
}
}
@Then("the current trader activity is: %activityTable")
public void theTradersActivityIs(ExamplesTable activityTable) {
for (int i = 0; i < activityTable.getRowCount(); i++) {
Parameters row = activityTable.withDefaults(this.ranksTable.getRowAsParameters(i)).getRowAsParameters(i);
System.out.println(row.valueAs("name", Trader.class).getName() + " ("
+ row.valueAs("rank", String.class, "N/A") + ") has done " + row.valueAs("trades", Integer.class)
+ " trades");
}
}
@Then("the traders returned are: %tradersTable")
public void theTradersReturnedAre(ExamplesTable tradersTable) {
OutcomesTable outcomes = new OutcomesTable();
outcomes.addOutcome("traders", searchedTraders.toString(), equalTo(toTraders(tradersTable).toString()));
outcomes.addOutcome("a success", "Any Value", equalTo("Any Value"));
outcomes.verify();
}
private List<Trader> toTraders(ExamplesTable table) {
List<Trader> traders = new ArrayList<Trader>();
List<Map<String, String>> rows = table.getRows();
for (Map<String, String> row : rows) {
String name = row.get("name");
String rank = row.get("rank");
traders.add(getService().newTrader(name, rank));
}
Collections.sort(traders);
return traders;
}
@Given("the stock exchange %stockExchange")
@Alias("the stock exchange <stockExchange>")
public void theStockExchange(@Named("stockExchange") String stockExchange) {
this.stockExchange = stockExchange;
}
@Given("the asset class %assetClass")
@Alias("the asset class <assetClass>")
public void theAssetClass(@Named("assetClass") String assetClass) {
this.assetClass = assetClass;
}
@Given("a stock of symbol %symbol and a threshold of %threshold")
@Alias("a stock of <symbol> and a <threshold>")
// alias used with examples table
public void aStock(@Named("symbol") String symbol, @Named("threshold") double threshold) {
stock = getService().newStock(symbol, threshold);
}
@When("the stock is traded at price %price")
@Aliases(values = { "the stock is sold at price %price", "the stock is exchanged at price %price",
"the stock is traded with <price>" })
// multiple aliases, one used with examples table
public void theStockIsTraded(@Named("price") double price) {
stock.tradeAt(price);
}
@Given("the alert status is %status")
// shows that matching pattern need only be unique for step type
public void theAlertStatusIsReset(@Named("status") String status) {
if (AlertStatus.OFF.name().startsWith(status) && stock != null) {
stock.resetAlert();
}
}
@Then("the alert status is %status")
@Alias("the trader is alerted with <status>")
// alias used with examples table
public void theAlertStatusIs(@Named("status") String status) {
assertThat(stock.getStatus().name(), equalTo(status));
}
@Then(value = "the alert status is currently %status", priority = 1)
// prioritise over potential match with previous method
public void theAlertStatusIsCurrently(@Named("status") String status) {
assertThat(stock.getStatus().name(), equalTo(status));
}
@When("the trader sells all stocks")
public void theTraderSellsAllStocks() {
trader.sellAllStocks();
}
@Then("the trader is left with no stocks")
public void theTraderIsLeftWithNoStocks() {
assertThat(trader.getStocks().size(), equalTo(0));
}
@Given("a trade type %tradeType")
public void givenATradeType(TradeType type) {
this.tradeType = type;
}
@Then("the current trade type is %type")
public void thenTheCurrentTradeTypeIs(String type) {
assertThat(this.tradeType.name(), equalTo(type));
}
@Then("the list of trade types is %types")
public void thenTheListTradeTypesIs(List<TradeType> types) {
List<String> values = new ArrayList<String>();
for (TradeType type : TradeType.values()) {
values.add(type.name());
}
assertThat(types.toString(), equalTo(values.toString()));
}
enum TradeType {
BUY, SELL;
}
// Method used as dynamical parameter converter
@AsParameterConverter
public Trader retrieveTrader(String name) {
for (Trader trader : traders) {
if (trader.getName().equals(name)) {
return trader;
}
}
return mockTradePersister().retrieveTrader(name);
}
static TraderPersister mockTradePersister() {
return new TraderPersister(new Trader("Mauro", asList(new Stock("STK1", 10.d))));
}
}