public void WhenISendDataThruPostWithResponseAction(Table table)
{
Order order = table.CreateSet<Order>().Single();
JsonServiceClient client = GetClient();
var response = client.Post<bool>(order);
ScenarioContext.Current[ResopnseKey] = response;
}
public void GivenTheTableIsCreatedInTheSchema(string tableName, string schemaName, Table table)
{
var tableActions = new TableActions(database.ConnectionString);
var def = new TableDefinition(new DatabaseObjectName(schemaName, tableName));
def.Columns.AddFromRaw(table.CreateSet<ColumnDefinitionRaw>());
tableActions.Create(def);
}
public void ThenIRequestDataThruGetAction(Table table)
{
Order expected = table.CreateSet<Order>().Single();
var actual = (List<Order>)ScenarioContext.Current[ResopnseKey];
Assert.Equal(1, actual.Count);
Assert.True(expected.Equals(actual.Single()));
}
public async Task WhenISettleTheFollowingBets(string securityKey, Table table)
{
var bets = table.CreateSet <TypeAndAmount>();
var betIdsList = GetOrCreate(SR.roundIdsList, () => new List <string>());
var txIdsList = GetOrCreate(SR.txIdsList, () => new List <string>());
var i = 0;
var previousTransactionId = Get <string>(SR.transactionId);
var response =
await JsonPostSecure <BatchSettleResponse>(Config.GameApiUrl + "api/mock/batch/bets/settle",
Get <string>(SR.accesstoken),
new BatchSettle
{
BatchId = NewStringId,
SecurityKey = securityKey,
Transactions =
bets.Select(taa => new BatchCommandTransactionRequest
{
Id = Set(SR.transactionId, NewStringId),
ReferenceId = txIdsList[i],
RoundId = betIdsList[i++],
CurrencyCode = "RMB",
Amount = taa.Amount,
BrandCode = "138",
TransactionType =
taa.Type == "WIN"
? BatchSettleBetTransactionType.Win
: BatchSettleBetTransactionType.Lose
})
.ToList()
});
Set(SR.response, response);
}
public void GivenADefaultSetOfWhingers(Table table)
{
foreach (var item in table.CreateSet<WhingerEntity>())
{
WhingePoolApplicationContext.WhingersTable.EnsureInstance(item);
}
}
public void GivenTheProcedureIsCreatedWithBody(string procedureName, string body, Table table)
{
ProcedureDefinition definition = new ProcedureDefinition(DatabaseObjectName.FromName(procedureName));
definition.Parameters.AddFromRaw(table.CreateSet<ProcedureParameterRaw>());
definition.Body = body;
definition.CreateOrReplace(database);
}
public void GivenTheVoucherProcessMetadataContainsTheFollowingData(Table table)
{
var folder = ScenarioContext.Current.Get<string>("folder");
var voucher = ScenarioContext.Current.Get<Voucher>("voucher");
var voucherBatch = ScenarioContext.Current.Get<VoucherBatch>("voucherBatch");
var voucherProcesses = table.CreateSet<VoucherProcess>().ToList();
if (voucherProcesses.Count() != 1)
{
Assert.Inconclusive("Currently only 1 voucherProcess is supported");
}
var imageExchangeVoucher = new ImageExchangeVoucher
{
voucher = voucher,
voucherBatch = voucherBatch,
voucherProcess = voucherProcesses.Single()
};
var voucherFilePrefix = string.Format("VOUCHER_{0}_{1}", voucher.processingDate.ToString("ddMMyyyy"), voucher.documentReferenceNumber);
var voucherFileFullPathAndPrefix = Path.Combine(folder, voucherFilePrefix);
WriteMetaData(voucherFileFullPathAndPrefix, imageExchangeVoucher);
WriteImage(voucherFileFullPathAndPrefix, "FRONT");
WriteImage(voucherFileFullPathAndPrefix, "REAR");
}
public async Task WhenIBatchSettleTheFollowingBets(string securityKey, Table table)
{
var bets = table.CreateSet <PlayerTypeAndAmount>();
var playerData = Get <Dictionary <string, PlayerData> >(SR.PlayerData);
var response =
await JsonPostSecure <BatchSettleResponse>(Config.GameApiUrl + "api/mock/batch/bets/settle",
Get <string>(SR.accesstoken),
new BatchSettle
{
BatchId = NewStringId,
SecurityKey = securityKey,
Transactions =
bets.Select(taa => new BatchCommandTransactionRequest
{
Id = Set(SR.transactionId, NewStringId),
UserId = playerData[taa.PlayerName].PlayerId,
ReferenceId = playerData[taa.PlayerName].LastPlaceBetTransactionId,
RoundId = playerData[taa.PlayerName].RoundId,
CurrencyCode = "RMB",
Amount = taa.Amount,
BrandCode = "138",
TransactionType =
taa.Type == "WIN"
? BatchSettleBetTransactionType.Win
: BatchSettleBetTransactionType.Lose
})
.ToList()
});
Set(SR.response, response);
}
public void GivenIHaveASetOfPerformances(Table table)
{
var performances = table.CreateSet<PerformanceScore>().ToList();
var generator = new TeamScoreGenerator();
var scores = generator.From(performances, null);
_reporting = new TeamScoreReporting(scores);
}
public void WhenIAddTheFollowingItemsToOrder(string orderNumber, Table table)
{
using (var context = new ShopAnyWareSql())
{
var order = context.Orders.SingleOrDefault(o => o.OrderNumber.Equals(orderNumber));
Assert.IsNotNull(order);
var contoller = this.GetItemsController();
var itemViewModels = table.CreateSet<OrderItemViewModel>();
var actuals = new List<OrderItemViewModel>();
foreach (var itemViewModel in itemViewModels)
{
itemViewModel.OrderId = order.Id;
var result = contoller.AddItemToOrder(itemViewModel) as JsonNetResult;
Assert.That(result, Is.Not.Null);
if (result == null)
{
continue;
}
var actual = result.Data as OrderItemViewModel;
actuals.Add(actual);
}
ScenarioContext.Current.Set(actuals);
}
}
public void WhenTheTable_BackedViewIsCreated(string viewName, Table table)
{
var definition = new TableDefinition("tbl" + viewName);
definition.Columns.AddFromRaw(table.CreateSet<ColumnDefinitionRaw>());
definition.CreateOrReplace(database);
definition.CreateView(database, viewName);
}
public void ThenTheDefinitionOfViewShouldMatchSystemTablesDefinition(string viewName, Table table)
{
var definition = new TableDefinition(viewName);
definition.Columns.AddFromRaw(table.CreateSet<ColumnDefinitionRaw>());
var checker = new ViewCheck(database.ConnectionString);
checker.VerifyMatch(definition, TableDefinitionInterrogationStrategyType.SystemTables);
}
public void WhenIUpdateDataThruPutAsyncActionWithResponse(Table table)
{
UpdateOrder request = table.CreateSet<UpdateOrder>().Single();
JsonServiceClient client = GetClient();
bool response = client.PutAsync<bool>(request).Result;
ScenarioContext.Current[ResopnseKey] = response;
}
public void WhenIFillInTheFollowingFields(Table table)
{
var fields = table.CreateSet<Field>();
foreach(var field in fields)
{
FillIn(field.Value, labelText: field.Name);
}
}
public void Givenขอมลการขอยนยนเบอรโทรทงหมดในระบบเปน(Table table)
{
var verifications = table.CreateSet<VerificationPhoneInformation>();
var mockAccountDac = ScenarioContext.Current.Get<Moq.Mock<IAccountDataAccess>>();
mockAccountDac.Setup(dac => dac.VerifyPhoneSuccess(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()));
mockAccountDac.Setup(dac => dac.GetVerificationPhoneByVerificationCode(It.IsAny<string>(), It.IsAny<string>())).Returns<string,string>
((userId,verificationCode) => verifications.FirstOrDefault(v => v.VerificationCode.Equals(verificationCode, StringComparison.CurrentCultureIgnoreCase)));
}
public void ThenTheResultShouldBeReturnedAssist(Table resultTable)
{
Person person = resultTable.CreateSet<Person>().ToList()[0];
var searchResult = ScenarioContext.Current.Get<List<Person>>(SEARCH_RESULT_KEY);
searchResult.Should().Contain.Item(person);
}
public void Givenรายชอผโชคดทงหมดในระบบเปนดงน(Table table)
{
var winnerQry = table.CreateSet<WinnerInformation>();
var mockRewardDac = ScenarioContext.Current.Get<Moq.Mock<IRewardDataAccess>>();
mockRewardDac.Setup(dac => dac.GetAllWinners()).Returns(() => winnerQry);
mockRewardDac.Setup(dac => dac.GetWinnersByUserId(It.IsAny<string>()))
.Returns<string>(userId => winnerQry.Where(it => it.AccountSecrectCode.Equals(userId, StringComparison.CurrentCultureIgnoreCase)));
}
public void GivenThereIsATestWithTheFollowingTestItems(Table table)
{
var itemList = table.CreateSet<TestItem>();
var test = new Test(itemList);
ScenarioContext.Current.Add(testKey, test);
}
public void WhenIEnterPizzaData(Table table)
{
var pizzas = table.CreateSet<PizzaModel>();
var nameInput = BaseSteps.Driver.FindElement(By.Id("new_pizza_name"));
foreach (var pizza in pizzas)
{
nameInput.SendKeys(pizza.Name);
}
}
public void Givenผใชในระบบมดงน(Table table)
{
var accounts = table.CreateSet<AccountInformation>().ToList();
var mockAccountDac = ScenarioContext.Current.Get<Moq.Mock<IAccountDataAccess>>();
mockAccountDac.Setup(it => it.GetAccountBySecrectCode(It.IsAny<string>())).Returns<string>(it =>
{
return accounts.FirstOrDefault(account => account.SecretCode == it);
});
}
public async Task WhenIPlaceBetsForAmount(string gameId, Table table)
{
var bets = table.CreateSet(tr => Decimal.Parse(tr.Values.First()));
foreach (var amount in bets)
{
await WhenIBet(amount, gameId);
}
}
public void EntaoEuVejo(Table table)
{
var blocos = table.CreateSet<Bloco>();
foreach (var bloco in blocos)
{
Assert.IsTrue(Browser.HasContent(bloco.Nome),
"Texto não encontrado na página: {0}", bloco.Nome);
}
}
public void GivenTheNotificationHasTheFollowingActions(Table table)
{
var actions = table.CreateSet<NotificationAction>();
foreach (var notificationAction in actions)
{
_currentNotification.AddNewActionCommand.Execute(null);
var action = _currentNotification.Actions.Last();
action.SelectedActionType = action.ActionTypes.First(at => at.Data == notificationAction.ActionType);
}
}
public void ix(Table table)
{
var db = GetTheDatabase();
db.AdminAccounts.DeleteAll();
var adminAccounts = table.CreateSet<AdminAccount>();
foreach (var adminAccount in adminAccounts)
db.AdminAccounts.Insert(adminAccount);
}
public void GivenขอมลRewordgroupทอยในระบบคอ(Table table)
{
var rewardGroup = table.CreateSet<RewardGroupInformation>()
.OrderBy(it => it.ExpiredDate)
.ToList();
var mockRewardDac = ScenarioContext.Current.Get<Moq.Mock<IRewardDataAccess>>();
mockRewardDac
.Setup(it => it.GetRewardGroup())
.Returns(() => rewardGroup);
}
public void GivenTheDatabaseContainsTheFollowingItems(Table table)
{
IEnumerable<Item> items = table.CreateSet<Item>();
foreach (Item item in items)
{
_db.Items.Add(item);
}
_db.SaveChanges();
}
public void ThenSystemSendStudentListAre(Table table)
{
var expected = table.CreateSet<GetStudentListRespond>();
var actual = ScenarioContext.Current.Get<IEnumerable<GetStudentListRespond>>();
var expectedString = JsonConvert.SerializeObject(expected);
var actualString = JsonConvert.SerializeObject(actual);
Assert.Equal(expectedString, actualString);
}
public void GivenTheFollowingPromotionsExist(Table table)
{
var promotions = table.CreateSet<Promotion>();
var promotionRepository = new Mock<IPromotionRepository>();
promotionRepository.Setup(x => x.GetPromotions())
.Returns(promotions);
ScenarioContext.Current.Set(promotionRepository.Object);
}
public void ThenISeeTheDetailsOfThisTalk(Table table)
{
//var appiumDriver = _appiumDriverContext.Driver;
var fieldValueRows = table.CreateSet<FieldValueRow>();
foreach (var fieldValueRow in fieldValueRows)
{
//AppiumWebElement element = appiumDriver.FindElementByAccessibilityId(fieldValueRow.Field);
//element.Text.Should().Be(fieldValueRow.Value);
}
}
public void GivenIHaveStores(Table table)
{
var storeRepo = RecallAidHelper.GetReal<StoreRepo>();
var stores = table.CreateSet<Store>();
foreach (var store in stores)
{
storeRepo.Save(store);
}
}
public void WhenIEnterIngredientData(Table table)
{
var ingredients = table.CreateSet<IngredientModel>();
var nameInput = BaseSteps.Driver.FindElement(By.Name("name"));
var priceInput = BaseSteps.Driver.FindElement(By.Name("price"));
foreach(var ingredient in ingredients)
{
nameInput.SendKeys(ingredient.Name);
priceInput.SendKeys(ingredient.Price.ToString());
}
}
public void ThenSystemSendCourseMapStatusBackAre(Table table)
{
var expected = table.CreateSet<CourseMapStatusRespond>();
var actual = ScenarioContext.Current.Get<IEnumerable<CourseMapStatusRespond>>();
Assert.Equal(expected.Count(), actual.Count());
var expectedString = JsonConvert.SerializeObject(expected);
var actualString = JsonConvert.SerializeObject(actual);
Assert.Equal(expectedString, actualString);
}
public void GivenTheVoucherBatchMetadataContainsTheFollowingData(Table table)
{
var voucherBatches = table.CreateSet<VoucherBatch>().ToList();
if (voucherBatches.Count() != 1)
{
Assert.Inconclusive("Currently only 1 voucherBatch is supported");
}
ScenarioContext.Current.Add("voucherBatch", voucherBatches.Single());
}
public async Task WhenIWinMultipleAmounts(Table table)
{
var roundId = Get <string>(SR.roundId);
var placeBetTxId = Get <string>(SR.transactionId);
var transactions = new List <BetCommandTransactionRequest>();
var betAmounts = table.CreateSet(tr => Decimal.Parse(tr.Values.First()));
foreach (var betAmount in betAmounts)
{
transactions.Add(new BetCommandTransactionRequest
{
Id = Set(SR.transactionId, NewStringId),
ReferenceId = placeBetTxId,
RoundId = roundId,
CurrencyCode = "RMB",
TimeStamp = DateTimeOffset.UtcNow,
Amount = betAmount
});
}
await SendWinBetTransactions(transactions);
}
public void WhenUserProvidesValuesOnFields(Table table)
{
var fields = table.CreateSet <Fields>();
fields.ForEach(row => Element <ITextInputField>(row.Field).SendString(row.Value));
}
public void WhenUserSelectsDropdownsWithVaues(Table table)
{
var fields = table.CreateSet <Fields>();
fields.ForEach(row => Element <IDropDown>(row.Field).ClickByText(row.Value));
}
