public void Setup()
{
_fakeScenarioContext = A.Fake<IScenarioContext>();
_fakeKeyGenerator = A.Fake<IKeyGenerator>();
A.CallTo(() => _fakeKeyGenerator.GenerateKey(A<Type>.Ignored, A<MethodInfo>.Ignored)).Returns("testkey");
_proxyInterceptor = new ProxyInterceptor(_fakeScenarioContext, _fakeKeyGenerator);
_proxyGenerator = new ProxyGenerator();
}
/// <summary>
/// Gets the rated usage scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The rated usage scenarios.</returns>
private static IPartnerScenario GetRatedUsageScenarios(IScenarioContext context)
{
var ratedUsageScenarios = new IPartnerScenario[]
{
new GetCustomerUsageSummary(context),
new GetCustomerSubscriptionsUsage(context),
new GetSubscriptionResourceUsage(context),
new GetSubscriptionUsageRecords(context),
new GetSubscriptionUsageSummary(context)
};
return(new AggregatePartnerScenario("Rated usage samples", ratedUsageScenarios, context));
}
/// <summary>
/// Gets the subscription scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The subscription scenarios.</returns>
private static IPartnerScenario GetSubscriptionScenarios(IScenarioContext context)
{
var subscriptionScenarios = new IPartnerScenario[]
{
new GetSubscription(context),
new GetSubscriptions(context),
new GetSubscriptionsByOrder(context),
new UpdateSubscription(context),
new UpgradeSubscription(context),
new AddSubscriptionAddOn(context)
};
return(new AggregatePartnerScenario("Subscription samples", subscriptionScenarios, context));
}
/// <summary>
/// Gets the invoice scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The invoice scenarios.</returns>
private static IPartnerScenario GetInvoiceScenarios(IScenarioContext context)
{
var invoiceScenarios = new IPartnerScenario[]
{
new GetAccountBalance(context),
new GetInvoice(context),
new GetInvoiceLineItems(context, context.Configuration.Scenario.InvoicePageSize),
new GetPagedInvoices(context, context.Configuration.Scenario.InvoicePageSize),
new GetInvoiceSummaries(context),
new GetInvoiceStatement(context)
};
return(new AggregatePartnerScenario("Invoice samples", invoiceScenarios, context));
}
/// <summary>
/// Gets the service request scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The service request scenarios.</returns>
private static IPartnerScenario GetServiceRequestsScenarios(IScenarioContext context)
{
var serviceRequestsScenarios = new IPartnerScenario[]
{
new CreatePartnerServiceRequest(context),
new GetCustomerServiceRequests(context),
new GetPagedPartnerServiceRequests(context, context.Configuration.Scenario.ServiceRequestPageSize),
new GetPartnerServiceRequestDetails(context),
new GetServiceRequestSupportTopics(context),
new UpdatePartnerServiceRequest(context)
};
return(new AggregatePartnerScenario("Service request samples", serviceRequestsScenarios, context));
}
/// <summary>
/// Gets the offer scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The offer scenarios.</returns>
private static IPartnerScenario GetOfferScenarios(IScenarioContext context)
{
var offerScenarios = new IPartnerScenario[]
{
new GetOffer(context),
new GetOfferCategories(context),
new GetOffers(context),
new GetPagedOffers(context, context.Configuration.Scenario.DefaultOfferPageSize),
new GetCustomerOffers(context),
new GetCustomerOfferCategories(context)
};
return(new AggregatePartnerScenario("Offer samples", offerScenarios, context));
}
private static async Task CaseWhenThen(IScenarioContext context)
{
var result = (int) await Select(Cast(Case()
.When(Literal(1) + 2 == Literal(3))
.Then(17)
.Else(2),
SqlType.Int32))
.QueryScalar(context.Database);
if (result != 17)
{
throw new Exception("Something went wrong");
}
}
static Task ScenarioInit(IScenarioContext context)
{
var db = new MongoClient().GetDatabase("Test");
var testData = Enumerable.Range(0, 2000)
.Select(i => new User {
Name = $"Test User {i}", Age = i, IsActive = true
})
.ToList();
db.DropCollection("Users", context.CancellationToken);
return(db.GetCollection <User>("Users")
.InsertManyAsync(testData, cancellationToken: context.CancellationToken));
}
public ScenarioTestData(
IEnumerable <IScenario> scenarios,
AppSettings defaultAppSettings,
IScenarioContext context = null)
{
var all = scenarios.Select(s =>
{
s.Context = context;
s.And.AppSettings = s.And.AppSettings ?? defaultAppSettings;
return(s);
}).ToList();
ActiveScenarios = all;
ActiveTheories = ActiveScenarios.ToObjectArrays();
}
private static void CleanActors(IScenarioContext context)
{
var actionActors =
from action in context.Actions
select action.Actor;
var expectationActors =
from expectation in context.Actions
select expectation.Actor;
foreach (var actor in actionActors.Concat(expectationActors).Distinct())
{
actor.Artifacts.Clear();
}
}
/// <summary>
/// Gets the order scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The order scenarios.</returns>
private static IPartnerScenario GetOrderScenarios(IScenarioContext context)
{
var orderScenarios = new IPartnerScenario[]
{
new CreateOrder(context),
new GetOrderDetails(context),
new GetOrders(context),
new CreateAzureReservationOrder(context),
new GetOrdersByBillingCycleType(context),
new GetOrderProvisioningStatus(context),
new UpdateOrder(context)
};
return(new AggregatePartnerScenario("Order samples", orderScenarios, context));
}
/// <summary>
/// Gets the indirect model scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The invoice scenarios.</returns>
private static IPartnerScenario GetIndirectModelScenarios(IScenarioContext context)
{
var indirectModelScenarios = new IPartnerScenario[]
{
new GetIndirectResellers(context),
new CreateCustomerForIndirectReseller(context),
new GetIndirectResellersOfCustomer(context),
new PlaceOrderForCustomer(context),
new GetCustomersOfIndirectReseller(context),
new VerifyPartnerMpnId(context),
new GetSubscriptionsByMpnId(context)
};
return(new AggregatePartnerScenario("Indirect model samples", indirectModelScenarios, context));
}
/// <summary>
/// Gets the profile scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The profile scenarios.</returns>
private static IPartnerScenario GetProfileScenarios(IScenarioContext context)
{
var profileScenarios = new IPartnerScenario[]
{
new GetBillingProfile(context),
new GetLegalBusinessProfile(context),
new GetOrganizationProfile(context),
new GetMPNProfile(context),
new GetSupportProfile(context),
new UpdateBillingProfile(context),
new UpdateLegalBusinessProfile(context),
new UpdateOrganizationProfile(context),
new UpdateSupportProfile(context)
};
return(new AggregatePartnerScenario("Partner profile samples", profileScenarios, context));
}
/// <summary>
/// Gets the customer products scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The products for customer scenarios.</returns>
private static IPartnerScenario GetCustomerProductsScenarios(IScenarioContext context)
{
var customerProductsScenarios = new IPartnerScenario[]
{
new GetCustomerProducts(context),
new GetCustomerProductsByTargetSegment(context),
new GetCustomerProduct(context),
new GetCustomerSkus(context),
new GetCustomerSkusByTargetSegment(context),
new GetCustomerSku(context),
new GetCustomerAvailabilities(context),
new GetCustomerAvailabilitiesByTargetSegment(context),
new GetCustomerAvailability(context)
};
return(new AggregatePartnerScenario("Products for customers samples", customerProductsScenarios, context));
}
public MainHooks(
IObjectContainer objectContainer,
ScenarioContext scenarioContext,
CommandHistoryMockBuilder commandHistoryMockBuilder,
VariablesMockBuilder variablesMockBuilder,
StringsMockBuilder stringsMockBuilder,
MapMockBuilder mapMockBuilder)
{
_objectContainer = objectContainer;
_scenarioContext = scenarioContext;
_commandHistoryMockBuilder = commandHistoryMockBuilder;
_variablesMockBuilder = variablesMockBuilder;
_stringsMockBuilder = stringsMockBuilder;
_mapMockBuilder = mapMockBuilder;
_lazyLifetimeScope = new Lazy <ILifetimeScope>(() => _lifetimeScope !);
}
public async Task Exec(IScenarioContext context)
{
var table = AllTables.GetItAllColumnTypes(context.Dialect == SqlDialect.PgSql);
var jsonStringOriginal = await ReadAsJsonString(context, table);
await context.Database.Exec(SqQueryBuilder.Delete(table).All());
await Insert(context, jsonStringOriginal, table);
var jsonStringAfter = await ReadAsJsonString(context : context, table : table);
if (jsonStringOriginal != jsonStringAfter)
{
throw new Exception("Export/Import/Export was not correct");
}
}
/// <summary>
/// Gets the product scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The product scenarios.</returns>
private static IPartnerScenario GetProductScenarios(IScenarioContext context)
{
var productScenarios = new IPartnerScenario[]
{
new GetProducts(context),
new GetProductsByTargetSegment(context),
new GetProduct(context),
new GetSkus(context),
new GetSkusByTargetSegment(context),
new GetSku(context),
new GetAvailabilities(context),
new GetAvailabilitiesByTargetSegment(context),
new GetAvailability(context),
new CheckInventory(context)
};
return(new AggregatePartnerScenario("Product samples", productScenarios, context));
}
/// <summary>
/// Gets the subscription scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The subscription scenarios.</returns>
private static IPartnerScenario GetSubscriptionScenarios(IScenarioContext context)
{
var subscriptionScenarios = new IPartnerScenario[]
{
new GetSubscription(context),
new GetSubscriptions(context),
new GetSubscriptionsByOrder(context),
new GetSubscriptionSupportContact(context),
new UpdateSubscriptionSupportContact(context),
new GetSubscriptionProvisioningStatus(context),
new UpdateSubscription(context),
new UpgradeSubscription(context),
new AddSubscriptionAddOn(context),
new ConvertTrialSubscription(context),
};
return(new AggregatePartnerScenario("Subscription samples", subscriptionScenarios, context));
}
/// <summary>
/// Initializes a new instance of the <see cref="BasePartnerScenario"/> class.
/// </summary>
/// <param name="title">The scenario title.</param>
/// <param name="context">The scenario context.</param>
/// <param name="executionStrategy">The scenario execution strategy.</param>
/// <param name="childScenarios">The child scenarios attached to the current scenario.</param>
public BasePartnerScenario(string title, IScenarioContext context, IScenarioExecutionStrategy executionStrategy = null, IReadOnlyList <IPartnerScenario> childScenarios = null)
{
if (string.IsNullOrWhiteSpace(title))
{
throw new ArgumentException("title has to be set");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
this.Title = title;
this.Context = context;
this.ExecutionStrategy = executionStrategy ?? new PromptExecutionStrategy();
this.Children = childScenarios;
}
public async Task Exec(IScenarioContext context)
{
var tUser = AllTables.GetItUser();
var tCompany = AllTables.GetItCompany();
var unionResult = await SelectTop(2, (tUser.FirstName + "-" + tUser.LastName).As("Name")).From(tUser)
.Union(SelectTop(2, tCompany.CompanyName.As("Name")).From(tCompany))
.QueryList(context.Database, r => r.GetString("Name"));
Console.WriteLine("Union");
foreach (var name in unionResult)
{
Console.WriteLine(name);
}
var exceptSet = Values(unionResult
.Where((i, index) => index % 2 == 0)
.Select(i => new ExprValue[] { Literal(i) })
.ToList())
.As("EX", "Name");
var unionExceptResult = await SelectTop(2, (tUser.FirstName + "-" + tUser.LastName).As("Name")).From(tUser)
.Union(SelectTop(2, tCompany.CompanyName.As("Name")).From(tCompany))
.Except(Select(exceptSet.Alias.AllColumns()).From(exceptSet))
.QueryList(context.Database, r => r.GetString("Name"));
Console.WriteLine();
Console.WriteLine("Union Except");
foreach (var name in unionExceptResult)
{
Console.WriteLine(name);
}
for (int i = 0; i < unionResult.Count; i++)
{
if (i % 2 != 0)
{
if (unionResult[i] != unionExceptResult[i / 2])
{
throw new Exception(unionResult[i] + " != " + unionExceptResult[i / 2]);
}
}
}
}
/// <summary>
/// Gets the invoice scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The invoice scenarios.</returns>
private static IPartnerScenario GetInvoiceScenarios(IScenarioContext context)
{
var invoiceScenarios = new IPartnerScenario[]
{
new GetAccountBalance(context),
new GetInvoice(context),
new GetInvoiceLineItems(context, context.Configuration.Scenario.InvoicePageSize),
new GetPagedInvoices(context, context.Configuration.Scenario.InvoicePageSize),
new GetInvoiceSummaries(context),
new GetInvoiceStatement(context),
new GetInvoiceTaxReceiptStatement(context),
new GetEstimatesLinks(context),
new GetBillingLineItemsForOpenPeriodPaging(context, context.Configuration.Scenario.InvoicePageSize),
new GetUsageLineItemsForOpenPeriodPaging(context, context.Configuration.Scenario.InvoicePageSize),
new GetUsageLineItemsForClosePeriodPaging(context, context.Configuration.Scenario.InvoicePageSize)
};
return(new AggregatePartnerScenario("Invoice samples", invoiceScenarios, context));
}
public void Run(IScenarioContext context, int attemptsCount, int millisecondsTimeout, bool cleanActorsOnRetry)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (attemptsCount <= 0)
{
throw new ArgumentOutOfRangeException(nameof(attemptsCount));
}
if (millisecondsTimeout <= 0)
{
throw new ArgumentOutOfRangeException(nameof(millisecondsTimeout));
}
for (var i = 0; i < attemptsCount; i++)
{
if (cleanActorsOnRetry && i > 0)
{
CleanActors(context);
}
try
{
RunScenario(context);
break;
}
catch (ExpectationException)
{
if (i + 1 < attemptsCount)
{
Thread.Sleep(millisecondsTimeout);
}
else
{
throw;
}
}
}
}
public async Task Exec(IScenarioContext context)
{
string[] ids =
{
"admin'--",
"10; DROP TABLE members /*",
"Line1\r\n\tLine2\\%%\b",
"--",
"\'",
"\\",
"\\'",
"\\\\",
"`\"'",
"``\\`\\\\`\"\\\"\\\\\"'\\'\\\\'",
"\"\\\"'\'\\'*`\\`;"
};
var expr = Select(ids.Select(id => Literal(id).As(id)).ToList()).Done();
var res = await expr.Query(context.Database, new List <string>(),
(acc, r) =>
{
foreach (var id in ids)
{
acc.Add(r.GetString(id));
}
return(acc);
});
for (var index = 0; index < ids.Length; index++)
{
if (res[index] != ids[index])
{
context.WriteLine(context.Dialect.GetExporter().ToSql(expr));
throw new Exception("Sql Injection!");
}
}
}
public async Task Exec(IScenarioContext context)
{
var data = this.ReadUserData();
var utcNow = DateTime.UtcNow;
var userTable = AllTables.GetItUser();
var ids = await InsertDataInto(userTable, data)
.MapData(s => s
.Set(s.Target.ExternalId, s.Source.ExternalId)
.Set(s.Target.FirstName, s.Source.FirstName)
.Set(s.Target.LastName, s.Source.LastName)
.Set(s.Target.Email, s.Source.Email)
)
.AlsoInsert(s => s
.Set(s.Target.RegDate, utcNow)
.Set(s.Target.Version, 1)
.Set(s.Target.Created, utcNow)
.Set(s.Target.Modified, utcNow)
)
.Output(userTable.UserId, userTable.FirstName, userTable.LastName)
.QueryList(context.Database, r => $"{userTable.UserId.Read(r)}, {userTable.FirstName.Read(r)} {userTable.LastName.Read(r)}");
foreach (var id in ids.Take(3))
{
context.WriteLine(id);
}
context.WriteLine("...");
context.WriteLine($"Total users inserted: {ids.Count}");
var count = (long) await Select(Cast(CountOne(), SqlType.Int64)).From(userTable).QueryScalar(context.Database);
context.WriteLine($"Users count: {count}");
await InsertCustomers(context);
}
public async Task Exec(IScenarioContext context)
{
var tUser = AllTables.GetItUser();
var top2Users = await SelectTop(2, UserEmail.GetColumns(tUser))
.From(tUser)
.OrderBy(tUser.FirstName)
.QueryList(context.Database, r => UserEmail.Read(r, tUser));
Console.WriteLine(top2Users[0]);
Console.WriteLine(top2Users[1]);
if (context.Dialect != SqlDialect.TSql)
{
top2Users = await SelectTop(2, UserEmail.GetColumns(tUser))
.From(tUser)
.OrderBy(tUser.FirstName)
.Offset(5)
.QueryList(context.Database, r => UserEmail.Read(r, tUser));
Console.WriteLine(top2Users[0].Email);
Console.WriteLine(top2Users[1].Email);
}
}
/// <summary>
/// Gets the customer scenarios.
/// </summary>
/// <param name="context">A scenario context.</param>
/// <returns>The customer scenarios.</returns>
private static IPartnerScenario GetCustomerScenarios(IScenarioContext context)
{
var customerFilteringScenarios = new IPartnerScenario[]
{
new FilterCustomers("Filter by company name", CustomerSearchField.CompanyName, context),
new FilterCustomers("Filter by domain name", CustomerSearchField.Domain, context)
};
var customerScenarios = new IPartnerScenario[]
{
new CreateCustomer(context),
new CheckDomainAvailability(context),
new GetPagedCustomers(context, context.Configuration.Scenario.CustomerPageSize),
new AggregatePartnerScenario("Customer filtering", customerFilteringScenarios, context),
new GetCustomerDetails(context),
new DeleteCustomerFromTipAccount(context),
new GetCustomerManagedServices(context),
new GetCustomerRelationshipRequest(context),
new UpdateCustomerBillingProfile(context),
new ValidateCustomerAddress(context)
};
return(new AggregatePartnerScenario("Customer samples", customerScenarios, context));
}
private static async Task SelectAllColumns(IScenarioContext context)
{
void PrintColumns(ISqDataRecordReader r)
{
for (int i = 0; i < r.FieldCount; i++)
{
context.Write(r.GetName(i) + ",");
}
context.WriteLine(null);
}
var tUser = AllTables.GetItUser();
var tCustomer = AllTables.GetItCustomer();
await SelectTop(1, AllColumns()).From(tUser).Query(context.Database, PrintColumns);
await SelectTop(1, tUser.AllColumns()).From(tUser).Query(context.Database, PrintColumns);
await SelectTop(1, tUser.AllColumns(), tCustomer.AllColumns())
.From(tUser)
.InnerJoin(tCustomer, on: tCustomer.UserId == tUser.UserId)
.Query(context.Database, PrintColumns);
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateConfigurationPolicy"/> class.
/// </summary>
/// <param name="context">The scenario context.</param>
public CreateConfigurationPolicy(IScenarioContext context) : base("Create a new configuration policy", context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomerUserAssignLicenses"/> class.
/// </summary>
/// <param name="context">The scenario context.</param>
public CustomerUserAssignLicenses(IScenarioContext context) : base("Assign customer user a license", context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GetCustomerDirectoryRoles"/> class.
/// </summary>
/// <param name="context">The scenario context.</param>
public GetCustomerDirectoryRoles(IScenarioContext context) : base("Get customer directory roles", context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateCustomer"/> class.
/// </summary>
/// <param name="context">The scenario context.</param>
public CreateCustomer(IScenarioContext context) : base("Create a new customer", context)
{
}
public ProxyInterceptor(IScenarioContext scenarioContext, IKeyGenerator keyGenerator)
{
_scenarioContext = scenarioContext;
_keyGenerator = keyGenerator;
}
