C# Table.CreateSet方法代码示例

 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 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 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 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 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 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 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 GivenThereIsATestWithTheFollowingTestItems(Table table)
		{
			var itemList = table.CreateSet<TestItem>();
			var test = new Test(itemList);
			ScenarioContext.Current.Add(testKey, test);

			
		}

 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 WhenIFillInTheFollowingFields(Table table)
 {
     var fields = table.CreateSet<Field>();
     foreach(var field in fields)
     {
         FillIn(field.Value, labelText: field.Name);
     }
 }

        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);
        }