static public async Task ClassInit(TestContext context)
#endif
{
app = new KZApplication(test.Constants.MarketplaceUrl, test.Constants.AppName);
await app.Initialize();
EnqueueTestComplete();
}
public static void ClassInit(TestContext context)
{
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
}
public void WithGlobalFilter_WithInstanceFilter_ManyFilter_GlobalFilterDisabled_InstanceFilterDisabled()
{
using (var ctx = new TestContext(true, enableFilter1: false, enableFilter2: false, enableFilter3: false, enableFilter4: false))
{
ctx.Filter<Inheritance_Interface_Entity>(QueryFilterHelper.Filter.Filter5, entities => entities.Where(x => x.ColumnInt != 5));
ctx.Filter<Inheritance_Interface_IEntity>(QueryFilterHelper.Filter.Filter6, entities => entities.Where(x => x.ColumnInt != 6));
ctx.Filter<Inheritance_Interface_Base>(QueryFilterHelper.Filter.Filter7, entities => entities.Where(x => x.ColumnInt != 7));
ctx.Filter<Inheritance_Interface_IBase>(QueryFilterHelper.Filter.Filter8, entities => entities.Where(x => x.ColumnInt != 8));
ctx.Filter(QueryFilterHelper.Filter.Filter5).Disable();
ctx.Filter(QueryFilterHelper.Filter.Filter6).Disable();
ctx.Filter(QueryFilterHelper.Filter.Filter7).Disable();
ctx.Filter(QueryFilterHelper.Filter.Filter8).Disable();
Assert.AreEqual(9, ctx.Inheritance_Interface_Entities.Filter(
QueryFilterHelper.Filter.Filter1,
QueryFilterHelper.Filter.Filter2,
QueryFilterHelper.Filter.Filter3,
QueryFilterHelper.Filter.Filter4,
QueryFilterHelper.Filter.Filter5,
QueryFilterHelper.Filter.Filter6,
QueryFilterHelper.Filter.Filter7,
QueryFilterHelper.Filter.Filter8).Sum(x => x.ColumnInt));
}
}
private void TakeScreenshot(TestContext testContext)
{
var filename = Path.GetFullPath(testContext.FullyQualifiedTestClassName + ".jpg");
try
{
var screenLeft = SystemInformation.VirtualScreen.Left;
var screenTop = SystemInformation.VirtualScreen.Top;
var screenWidth = SystemInformation.VirtualScreen.Width;
var screenHeight = SystemInformation.VirtualScreen.Height;
// Create a bitmap of the appropriate size to receive the screenshot.
using (var bmp = new Bitmap(screenWidth, screenHeight))
{
// Draw the screenshot into our bitmap.
using (var g = Graphics.FromImage(bmp))
{
g.CopyFromScreen(screenLeft, screenTop, 0, 0, bmp.Size);
}
bmp.Save(filename, ImageFormat.Jpeg);
}
testContext.AddResultFile(filename);
}
catch (Exception ex)
{
Logger.WriteLine("An exception occured while trying to take screenshot:");
Logger.WriteLine(ex);
}
}
public void Many_Executor()
{
TestContext.DeleteAll(x => x.Association_Multi_OneToMany_Lefts);
TestContext.DeleteAll(x => x.Association_Multi_OneToMany_Right1s);
TestContext.DeleteAll(x => x.Association_Multi_OneToMany_Right2s);
using (var ctx = new TestContext())
{
var left = TestContext.Insert(ctx, x => x.Association_Multi_OneToMany_Lefts, 1).First();
left.Right1s = TestContext.Insert(ctx, x => x.Association_Multi_OneToMany_Right1s, 5);
left.Right2s = TestContext.Insert(ctx, x => x.Association_Multi_OneToMany_Right2s, 5);
ctx.SaveChanges();
}
using (var ctx = new TestContext())
{
var item = ctx.Association_Multi_OneToMany_Lefts
.Include(left => left.Right1s, true)
.Include(left => left.Right2s, true)
.First();
// TEST: context
Assert.AreEqual(11, ctx.ChangeTracker.Entries().Count());
}
}
public void Many_Property_Type()
{
TestContext.DeleteAll(x => x.Entity_Basic_Manies);
TestContext.Insert(x => x.Entity_Basic_Manies, 50);
using (var ctx = new TestContext())
{
// BEFORE
Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column1));
Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column2));
Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column3));
// ACTION
var entity = new Entity_Basic_Many {Column1 = 99, Column2 = 66, Column3 = 33};
var rowsAffected = ctx.Entity_Basic_Manies.Where(x => x.Column1 > 10 && x.Column1 <= 40).Update(x => new Entity_Basic_Many
{
Column1 = entity.Column1,
Column2 = entity.Column2,
Column3 = entity.Column3
});
// AFTER
Assert.AreEqual(3430, ctx.Entity_Basic_Manies.Sum(x => x.Column1));
Assert.AreEqual(2440, ctx.Entity_Basic_Manies.Sum(x => x.Column2));
Assert.AreEqual(1450, ctx.Entity_Basic_Manies.Sum(x => x.Column3));
Assert.AreEqual(30, rowsAffected);
}
}
public void Tag_NotEqual()
{
var testCacheKey = Guid.NewGuid().ToString();
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 1);
using (var ctx = new TestContext())
{
// BEFORE
var itemCountBefore = ctx.Entity_Basics.FromCache(testCacheKey).Count();
var cacheCountBefore = QueryCacheHelper.GetCacheCount();
TestContext.DeleteAll(x => x.Entity_Basics);
// AFTER
var itemCountAfter = ctx.Entity_Basics.FromCache(testCacheKey, Guid.NewGuid().ToString()).Count();
var cacheCountAfter = QueryCacheHelper.GetCacheCount();
// TEST: The item count are NOT equal (A new cache key is used, the query is materialized)
Assert.AreNotEqual(itemCountBefore, itemCountAfter);
Assert.AreEqual(0, itemCountAfter);
// TEST: The cache count are NOT equal (A new cache key is used)
Assert.AreEqual(cacheCountBefore + 1, cacheCountAfter);
}
}
public async Task TestGetClusterInfo()
{
// arrange
var ctx = new TestContext();
var urlProvider = ctx.UrlProviderFake;
var restReqExecutor = ctx.RestRequestExecutorFake;
var anyUri = Enumerable.Repeat(new Uri("anyscheme://anypath"), 1);
urlProvider.GetUrlAsync().Returns(Task.FromResult(anyUri));
var anyClusterInfo = new ClusterInfo
{
HadoopBuildVersion = "AnyBuildVersion",
HadoopVersion = "AnyVersion",
HadoopVersionBuiltOn = "AnyVersionBuildOn",
};
restReqExecutor.ExecuteAsync<ClusterInfo>(
Arg.Is<RestRequest>(
req =>
req.Resource == "ws/v1/cluster/info" && req.RootElement == "clusterInfo" &&
req.Method == Method.GET),
anyUri.First(),
CancellationToken.None).Returns(Task.FromResult(anyClusterInfo));
// act
var yarnClient = ctx.GetClient();
ClusterInfo actualClusterInfo = await yarnClient.GetClusterInfoAsync();
// assert
Assert.Equal(anyClusterInfo, actualClusterInfo);
var unused = urlProvider.Received(1).GetUrlAsync();
}
public async Task TestGetClusterMetrics()
{
var ctx = new TestContext();
var urlProvider = ctx.UrlProviderFake;
var restReqExecutor = ctx.RestRequestExecutorFake;
var anyUri = Enumerable.Repeat(new Uri("anyscheme://anypath"), 1);
urlProvider.GetUrlAsync().Returns(Task.FromResult(anyUri));
var anyClusterMetrics = new ClusterMetrics
{
ActiveNodes = 5,
AllocatedMB = 1000,
AllocatedVirtualCores = 10,
AppsCompleted = 301
};
restReqExecutor.ExecuteAsync<ClusterMetrics>(
Arg.Is<RestRequest>(
req =>
req.Resource == "ws/v1/cluster/metrics" && req.RootElement == "clusterMetrics" &&
req.Method == Method.GET),
anyUri.First(),
CancellationToken.None).Returns(Task.FromResult(anyClusterMetrics));
var yarnClient = ctx.GetClient();
ClusterMetrics actualClusterMetrics = await yarnClient.GetClusterMetricsAsync();
Assert.Equal(anyClusterMetrics, actualClusterMetrics);
var unused = urlProvider.Received(1).GetUrlAsync();
}
public void Initialize()
{
Context = new TestContext();
Context.Service.Start(Context.EndPoint);
Context.Client.Connect(Context.EndPoint);
Assert.IsTrue(Context.WaitFor(() => Context.ConnectedUsers.Count() == 1, Context.WaitingPeriod));
}
public void BracketedIdentifierSimplificationTest()
{
var expected = $@"#Region ""{FeaturesResources.Assembly} mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089""
' mscorlib.v4_0_30319_17626.dll
#End Region
Imports System.Runtime
Imports System.Runtime.InteropServices
Namespace System
<__DynamicallyInvokableAttribute> <AttributeUsage(AttributeTargets.Class Or AttributeTargets.Struct Or AttributeTargets.Enum Or AttributeTargets.Constructor Or AttributeTargets.Method Or AttributeTargets.Property Or AttributeTargets.Field Or AttributeTargets.Event Or AttributeTargets.Interface Or AttributeTargets.Delegate, Inherited:=False)> <ComVisible(True)>
Public NotInheritable Class [|ObsoleteAttribute|]
Inherits Attribute
<__DynamicallyInvokableAttribute>
Public Sub New()
<__DynamicallyInvokableAttribute>
Public Sub New(message As String)
<__DynamicallyInvokableAttribute> <TargetedPatchingOptOut(""Performance critical to inline this type of method across NGen image boundaries"")>
Public Sub New(message As String, [error] As Boolean)
<__DynamicallyInvokableAttribute>
Public ReadOnly Property IsError As Boolean
<__DynamicallyInvokableAttribute>
Public ReadOnly Property Message As String
End Class
End Namespace";
using (var context = new TestContext(LanguageNames.VisualBasic))
{
context.GenerateAndVerifySource("System.ObsoleteAttribute", expected);
}
}
public async Task TestConnection (TestContext ctx, CancellationToken cancellationToken,
InstrumentationConnectionProvider provider,
SimpleConnectionParameters parameters,
SimpleConnectionTestRunner runner)
{
await runner.Run (ctx, cancellationToken);
}
public void Thirty()
{
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 50);
using (var ctx = new TestContext())
{
// BEFORE
Assert.AreEqual(1225, ctx.Entity_Basics.Sum(x => x.ColumnInt));
// ACTION
var clock = new Stopwatch();
clock.Start();
var rowsAffected = ctx.Entity_Basics.Where(x => x.ColumnInt > 10 && x.ColumnInt <= 40).Update(x => new Entity_Basic { ColumnInt = 99 }, update =>
{
update.BatchDelayInterval = 50;
update.BatchSize = 5;
});
clock.Stop();
// AFTER
Assert.AreEqual(460, ctx.Entity_Basics.Sum(x => x.ColumnInt));
Assert.AreEqual(30, rowsAffected);
Assert.IsTrue(clock.ElapsedMilliseconds > 250 && clock.ElapsedMilliseconds < 600);
}
}
public void WithGlobalFilter_ManyFilter_Include()
{
using (var ctx = new TestContext(true, enableFilter1: false, enableFilter2: false, enableFilter3: false, enableFilter4: false, includeInterface: true, includeBaseClass: true, includeBaseInterface: true))
{
Assert.AreEqual(36, ctx.Inheritance_Interface_Entities.Sum(x => x.ColumnInt));
}
}
public void Tag_Expire()
{
var testCacheKey = Guid.NewGuid().ToString();
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 1);
using (var ctx = new TestContext())
{
// BEFORE
var itemCountBefore = ctx.Entity_Basics.FromCache(testCacheKey).Count();
var cacheCountBefore = QueryCacheHelper.GetCacheCount();
TestContext.DeleteAll(x => x.Entity_Basics);
QueryCacheManager.ExpireTag(testCacheKey);
var cacheCountExpired = QueryCacheHelper.GetCacheCount();
// TEST: The cache count are NOT equal (The cache key has been removed)
Assert.AreEqual(cacheCountBefore - 1, cacheCountExpired);
// AFTER
var itemCountAfter = ctx.Entity_Basics.FromCache(testCacheKey).Count();
var cacheCountAfter = QueryCacheHelper.GetCacheCount();
// TEST: The item count are NOT equal (The query has been expired)
Assert.AreNotEqual(itemCountBefore, itemCountAfter);
Assert.AreEqual(0, itemCountAfter);
// TEST: The cache count are NOT equal (The expired cache key is added)
Assert.AreEqual(cacheCountExpired + 1, cacheCountAfter);
Assert.AreEqual(cacheCountBefore, cacheCountAfter);
}
}
public static void InitializeAssembly(TestContext context)
{
//System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
#if NET
using (var dbContext = new EntityFramework5.DbContextTest.TestDbContextContainer())
{
dbContext.Database.CreateIfNotExists();
// Delete all data
var allOrders = (from x in dbContext.DbContextOrders
select x).ToList();
foreach (var x in allOrders)
{
dbContext.DbContextOrders.Remove(x);
}
var allCustomers = (from x in dbContext.DbContextCustomers
select x).ToList();
foreach (var x in allCustomers)
{
dbContext.DbContextCustomers.Remove(x);
}
var allProducts = (from x in dbContext.DbContextProducts
select x).ToList();
foreach (var x in allProducts)
{
dbContext.DbContextProducts.Remove(x);
}
dbContext.SaveChanges();
}
#endif
}
public async Task RestClientGetRequestReturnsResponse()
{
var tc = new TestContext();
var client = tc.GetRestClient();
var anyRequest = new RestRequest
{
Method = Method.GET,
Resource = AnyResource,
RootElement = AnyRootElement
};
var successfulResponseMessage = CreateSuccessfulResponseMessage();
tc.HttpClient.GetAsync(AnyRequestUri + anyRequest.Resource, CancellationToken.None)
.Returns(Task.FromResult(successfulResponseMessage));
var response =
await client.ExecuteRequestAsync<AnyResponse>(anyRequest, AnyRequestUri, CancellationToken.None);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(AnyStringField, response.Data.AnyStringField);
Assert.Equal(AnyIntField, response.Data.AnyIntField);
Assert.Null(response.Exception);
var unused = tc.HttpClient.Received(1).GetAsync(AnyRequestUri + anyRequest.Resource, CancellationToken.None);
}
public void WithGlobalFilter_SingleFilter_Enable()
{
using (var ctx = new TestContext(false, enableFilter1: true))
{
Assert.AreEqual(44, ctx.Inheritance_Interface_Entities.Sum(x => x.ColumnInt));
}
}
public void Many_Variable()
{
TestContext.DeleteAll(x => x.Entity_Basic_Manies);
TestContext.Insert(x => x.Entity_Basic_Manies, 50);
using (var ctx = new TestContext())
{
// BEFORE
Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column1));
Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column2));
Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column3));
// ACTION
var value1 = 99;
var value2 = 66;
var value3 = 33;
var rowsAffected = ctx.Entity_Basic_Manies.Where(x => x.Column1 > 10 && x.Column1 <= 40).Update(x => new Entity_Basic_Many
{
Column1 = value1,
Column2 = value2,
Column3 = value3
});
// AFTER
Assert.AreEqual(3430, ctx.Entity_Basic_Manies.Sum(x => x.Column1));
Assert.AreEqual(2440, ctx.Entity_Basic_Manies.Sum(x => x.Column2));
Assert.AreEqual(1450, ctx.Entity_Basic_Manies.Sum(x => x.Column3));
Assert.AreEqual(30, rowsAffected);
}
}
public static void ClassInitialize(TestContext context)
{
longPathDirectory = Util.MakeLongPath(context.TestDir);
longPathRoot = longPathDirectory.Substring(0, context.TestDir.Length + 1 + longPathDirectory.Substring(context.TestDir.Length + 1).IndexOf('\\'));
Directory.CreateDirectory(longPathDirectory);
Debug.Assert(Directory.Exists(longPathDirectory));
}
public void Queryable_AsNoTracking()
{
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 10);
using (var ctx = new TestContext())
{
// BEFORE
var futureValue1 = ctx.Entity_Basics.Where(x => x.ColumnInt < 5).OrderBy(x => x.ColumnInt).AsNoTracking().FutureValue();
var futureValue2 = ctx.Entity_Basics.Where(x => x.ColumnInt >= 5).OrderBy(x => x.ColumnInt).AsNoTracking().FutureValue();
// TEST: The batch contains 2 queries
Assert.AreEqual(2, QueryFutureManager.AddOrGetBatch(ctx.GetObjectContext()).Queries.Count);
var value = futureValue1.Value;
// AFTER
// TEST: The batch contains 0 queries
Assert.AreEqual(0, QueryFutureManager.AddOrGetBatch(ctx.GetObjectContext()).Queries.Count);
// TEST: The futureList1 has a value and the first item is returned
Assert.IsTrue(futureValue1.HasValue);
Assert.AreEqual(0, value.ColumnInt);
// TEST: The futureList2 has a value and the first item is returned
Assert.IsTrue(futureValue2.HasValue);
Assert.AreEqual(5, futureValue2.Value.ColumnInt);
// TEST: No entries has been loaded in the change tracker
Assert.AreEqual(0, ctx.ChangeTracker.Entries().Count());
}
}
internal static void TestNotReusedOnAssemblyDiffers(string projectLanguage)
{
var metadataSources = new[]
{
@"[assembly: System.Reflection.AssemblyVersion(""1.0.0.0"")] public class D {}",
@"[assembly: System.Reflection.AssemblyVersion(""2.0.0.0"")] public class D {}"
};
using (var context = new TestContext(projectLanguage))
{
var projectId = ProjectId.CreateNewId();
var metadataProject = context.CurrentSolution
.AddProject(projectId, "Metadata", "Metadata", LanguageNames.CSharp).GetProject(projectId)
.AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib)
.WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release));
var references = new List<MetadataReference>();
foreach (var source in metadataSources)
{
var newDoc = metadataProject.AddDocument("MetadataSource", source);
metadataProject = newDoc.Project;
references.Add(MetadataReference.CreateFromImage(metadataProject.GetCompilationAsync().Result.EmitToArray()));
metadataProject = metadataProject.RemoveDocument(newDoc.Id);
}
var project = context.DefaultProject.AddMetadataReference(references[0]);
var a = context.GenerateSource("D", project);
project = project.RemoveMetadataReference(references[0]).AddMetadataReference(references[1]);
var b = context.GenerateSource("D", project);
context.VerifyDocumentNotReused(a, b);
}
}
public static void IntializeAssembly(TestContext ctx)
{
// 根据配置文件中的设置来设置
// 测试数据库
DatabaseTestClass.TestService.DeployDatabaseProject();
DatabaseTestClass.TestService.GenerateData();
}
public void Single_Executor()
{
TestContext.DeleteAll(x => x.Association_OneToMany_Lefts);
TestContext.DeleteAll(x => x.Association_OneToMany_Rights);
using (var ctx = new TestContext())
{
var left = TestContext.Insert(ctx, x => x.Association_OneToMany_Lefts, 1).First();
left.Rights = TestContext.Insert(ctx, x => x.Association_OneToMany_Rights, 5);
ctx.SaveChanges();
}
using (var ctx = new TestContext())
{
var item = ctx.Association_OneToMany_Lefts.IncludeQuery(left => left.Rights.Where(x => x.ColumnInt > 2)).First();
// TEST: context
Assert.AreEqual(3, ctx.ChangeTracker.Entries().Count());
// TEST: right
Assert.AreEqual(2, item.Rights.Count);
if (item.Rights[0].ColumnInt == 3)
{
Assert.AreEqual(3, item.Rights[0].ColumnInt);
Assert.AreEqual(4, item.Rights[1].ColumnInt);
}
else
{
Assert.AreEqual(4, item.Rights[0].ColumnInt);
Assert.AreEqual(3, item.Rights[1].ColumnInt);
}
}
}
public void Queryable_AsTracking()
{
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 10);
using (var ctx = new TestContext())
{
// BEFORE
var cacheCountBefore = QueryFutureManager.Cache.Count();
var futureValue1 = ctx.Entity_Basics.Where(x => x.ColumnInt < 5).OrderBy(x => x.ColumnInt).FutureValue();
var futureValue2 = ctx.Entity_Basics.Where(x => x.ColumnInt >= 5).OrderBy(x => x.ColumnInt).FutureValue();
// TEST: The cache count are NOT equal (A new context has been added)
Assert.AreEqual(cacheCountBefore + 1, QueryFutureManager.Cache.Count());
var value = futureValue1.Value;
// AFTER
// TEST: The cache count are equal (The new context has been removed)
Assert.AreEqual(cacheCountBefore, QueryFutureManager.Cache.Count());
// TEST: The futureList1 has a value and the first item is returned
Assert.IsTrue(futureValue1.HasValue);
Assert.AreEqual(0, value.ColumnInt);
// TEST: The futureList2 has a value and the first item is returned
Assert.IsTrue(futureValue2.HasValue);
Assert.AreEqual(5, futureValue2.Value.ColumnInt);
// TEST: The first item of both FutureValue has been added
Assert.AreEqual(2, ctx.ChangeTracker.Entries().Count());
}
}
public static void Initialize(TestContext context)
{
Connection.DisableServerCertValidation = true;
// uncomment the following to write frame traces
//Trace.TraceLevel = TraceLevel.Frame;
//Trace.TraceListener = (f, a) => System.Diagnostics.Trace.WriteLine(DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a));
}
public Task Test (TestContext ctx, CancellationToken cancellationToken,
InstrumentationConnectionProvider provider,
GenericConnectionInstrumentParameters parameters,
GenericConnectionInstrumentTestRunner runner)
{
return runner.Run (ctx, cancellationToken);
}
internal static void GenerateAndVerifySource(string metadataSource, string symbolName, string projectLanguage, string expected, bool compareTokens = true, bool includeXmlDocComments = false)
{
using (var context = new TestContext(projectLanguage, SpecializedCollections.SingletonEnumerable(metadataSource), includeXmlDocComments))
{
context.GenerateAndVerifySource(symbolName, expected, compareTokens);
}
}
public void IncludeEntityAdded_IsFalse()
{
TestContext.DeleteAll(x => x.AuditEntries);
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 2);
var audit = AuditHelper.AutoSaveAudit();
audit.Configuration.IncludeEntityAdded = false;
using (var ctx = new TestContext())
{
var list = ctx.Entity_Basics.OrderBy(x => x.ID).ToList();
// INSERT one
TestContext.Insert(ctx, x => x.Entity_Basics, 1);
// DELETE one
ctx.Entity_Basics.Remove(list[0]);
// UPDATE one
list[1].ColumnInt++;
ctx.SaveChanges(audit);
}
// UnitTest - Audit
{
var entries = audit.Entries;
// Entries
{
// Entries Count
Assert.AreEqual(2, entries.Count);
// Entries State
Assert.AreEqual(AuditEntryState.EntityModified, entries[0].State);
Assert.AreEqual(AuditEntryState.EntityDeleted, entries[1].State);
}
}
// UnitTest - Audit (Database)
{
using (var ctx = new TestContext())
{
// ENSURE order
var entries = ctx.AuditEntries.OrderBy(x => x.AuditEntryID).ToList();
// Entries
{
// Entries Count
Assert.AreEqual(2, entries.Count);
// Entries State
Assert.AreEqual(AuditEntryState.EntityModified, entries[0].State);
Assert.AreEqual(AuditEntryState.EntityDeleted, entries[1].State);
}
}
}
}
public Task Test_HTMLBinding_Stress_Collection_CreateBinding(JavascriptBindingMode imode, TestPerformanceKind context, TestContext ipath = TestContext.Index)
{
int r = 100;
var datacontext = new TwoList();
datacontext.L1.AddRange(Enumerable.Range(0, r).Select(i => new Skill()));
var stopWatch = new Stopwatch();
stopWatch.Start();
var test = new TestInContext()
{
Path = ipath,
Bind = (win) => HTML_Binding.Bind(win, datacontext, imode),
Test = (mb) =>
{
stopWatch.Stop();
var ts = stopWatch.ElapsedMilliseconds;
_Logger.Info($"Perf: {((double) (ts)) / 1000} sec for {r} iterations");
var js = mb.JSRootObject;
var col = GetSafe(() => GetCollectionAttribute(js, "L1"));
col.GetArrayLength().Should().Be(r);
CheckVsExpectation(ts, context);
}
};
return RunAsync(test);
}
public static System.Collections.Generic.HashSet <TestEntity> GetEntitiesWithMultipleEntityIndicesValue2(this TestContext context, string value2)
{
return(((JCMG.EntitasRedux.EntityIndex <TestEntity, string>)context.GetEntityIndex(Contexts.MultipleEntityIndicesValue2)).GetEntities(value2));
}
public static void Setup(TestContext context)
{
// Launch the Calculator app
WindowTransformSession = Utility.CreateNewSession(CommonTestSettings.CalculatorAppId);
Assert.IsNotNull(WindowTransformSession);
}
public RegisterCheckSuccessSteps(TestContext context) : base(context)
{
}
public static void ClassInitialize(TestContext c)
{
}
public static void ClassInitialize(TestContext context)
{
GraphBrowser.Initialize();
}
public static void ClassInitialize(TestContext context)
{
_testDIContext = TestDIContextFactory.CreateDefaultContext();
}
public static void Init(TestContext context)
{
Reusable.Logging.LoggerFactory.Initialize <Reusable.Logging.Adapters.NLogFactory>();
}
public static void ClassInit(TestContext context)
{
}
public static void ClassInitialize(TestContext a)
{
_mockClient = new Mock <AmazonStepFunctionsClient>("access key", "secret", Amazon.RegionEndpoint.USEast1);
}
public static System.Collections.Generic.HashSet <TestEntity> GetEntitiesWithPosition2(this TestContext context, EntitasRedux.Tests.IntVector2 position, EntitasRedux.Tests.IntVector2 size)
{
return(((EntitasRedux.Tests.MyCustomEntityIndex)(context.GetEntityIndex(Contexts.EntitasReduxTestsMyCustomEntityIndex))).GetEntitiesWithPosition2(position, size));
}
public static void Setup(TestContext context)
{
BaseSetup(context);
}
public static void ClassInitialize(TestContext context)
{
PtfTestClassBase.Initialize(context);
}
public static void AssemblyInit(TestContext context)
{
AssertFailureExceptionFactory.ConfigureForMicrosoftTest();
TestSetupHelpers.CleanupProcess(WebSec.Common.Constants.ChromeDriver);
TestSetupHelpers.StartIisExpress();
}
public static void SuiteSetUp(TestContext testContext)
{
testFile1 = WriteStreamToTempFile("emergency-backup.log");
testFile2 = WriteStreamToTempFile("empty.txt");
testFile3 = WriteStreamToTempFile("binary.jar");
}
private void RegisterHearingServices(TestContext context)
{
context.Config.ServicesConfiguration = Options.Create(_configRoot.GetSection("Services").Get <ServicesConfiguration>()).Value;
context.Config.ServicesConfiguration.BookingsApiResourceId.Should().NotBeNullOrEmpty();
}
public static void Initialize(TestContext context)
{
_zapClient = new ClientApi(_zapUrl, _zapPort, _zapApiKey);
}
private static void RegisterApiSettings(TestContext context)
{
context.Response = new HttpResponseMessage();
}
private void RegisterTestSettings(TestContext context)
{
context.Config.TestSettings = Options.Create(_configRoot.GetSection("Testing").Get <TestSettings>()).Value;
ConfigurationManager.VerifyConfigValuesSet(context.Config.TestSettings);
}
Task ITestMethodLifecycle.OnTestEndAsync(TestContext context, Exception exception, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
public ConfigHooks(TestContext context)
{
_configRoot = ConfigurationManager.BuildConfig("D76B6EB8-F1A2-4A51-9B8F-21E1B6B81E4F");
context.Config = new Config();
context.UserAccounts = new List <UserAccount>();
}
public static void Initialize(TestContext textContext)
{
DocumentClientSwitchLinkExtension.Reset("HeadersValidationTests");
}
public static void DoDeployment(TestContext context)
{
AssertListener.Initialize();
}
public static void ClassInitialize(TestContext testContext)
{
TestEnvironment.Initialize(testContext);
}
Task ITestMethodLifecycle.OnTestStartAsync(TestContext context, CancellationToken cancellationToken)
{
Context = context;
return(Task.CompletedTask);
}
public static void Intialize(TestContext context)
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
public static void ClassInit(TestContext testContext)
{
_testContext = testContext;
}
public async Task BeforeAllAsync()
{
await Profiler.Run(
async() =>
{
// Set up logging
LogEventLevel consoleLevel = Context.Current.Verbose
? LogEventLevel.Verbose
: LogEventLevel.Information;
var loggerConfig = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.NUnit(consoleLevel);
Context.Current.LogFile.ForEach(f => loggerConfig.WriteTo.File(f));
Log.Logger = loggerConfig.CreateLogger();
// Install IoT Edge
using (var cts = new CancellationTokenSource(Context.Current.SetupTimeout))
{
// NUnit's [Timeout] attribute isn't supported in .NET Standard
// and even if it were, it doesn't run the teardown method when
// a test times out. We need teardown to run, to remove the
// device registration from IoT Hub and stop the daemon. So
// we have our own timeout mechanism.
DateTime startTime = DateTime.Now;
CancellationToken token = cts.Token;
Assert.IsNull(this.device);
this.device = await EdgeDevice.GetOrCreateIdentityAsync(
Context.Current.DeviceId,
this.iotHub,
token);
await this.daemon.UninstallAsync(token);
await this.daemon.InstallAsync(
this.device.ConnectionString,
Context.Current.PackagePath,
Context.Current.Proxy,
token);
try
{
await this.daemon.WaitForStatusAsync(EdgeDaemonStatus.Running, token);
var agent = new EdgeAgent(this.device.Id, this.iotHub);
await agent.WaitForStatusAsync(EdgeModuleStatus.Running, token);
await agent.PingAsync(token);
}
// ReSharper disable once RedundantCatchClause
catch
{
throw;
}
finally
{
string prefix = $"{Context.Current.DeviceId}-{TestContext.CurrentContext.Test.NormalizedName()}";
IEnumerable <string> paths = await EdgeLogs.CollectAsync(startTime, prefix, token);
foreach (string path in paths)
{
TestContext.AddTestAttachment(path);
}
}
}
},
"Completed end-to-end test setup");
}
public static void Init(TestContext context)
{
SubscribeToUnhandledExceptions(context, true);
}
public static void ClassInit(TestContext context)
{
mapper = AutoMapperHelper.RunCreateMaps();
}
public static new void ClassInitialize(TestContext testContext)
{
TestSuiteBase.ClassInitialize(testContext);
}
