| public static NotNull ( object @object, string userMessage ) : void | ||
| @object | object | |
| userMessage | string | |
| return | void | |
public void PrivateStatic_ExplicitName()
{
MethodInfo methodInfo = null;
// Case-sensitive name
methodInfo = MR.GetMethodInfo <PrivateStatic_int>(typeof(TestClass), "PrivateStatic", true);
XAssert.NotNull(methodInfo);
// Case-sensitive name - should fail
XAssert.Throws <MissingMethodException>(() => MR.GetMethodInfo <PrivateStatic_int>(typeof(TestClass), "privatestatic", true));
// Case-insensitive name
methodInfo = MR.GetMethodInfo <PrivateStatic_int>(typeof(TestClass), "privatestatic", true, true);
XAssert.NotNull(methodInfo);
}
public void ProtectedStatic_ExplicitName()
{
ProtectedStatic_string dg = null;
// Case-sensitive name
dg = MR.GetMethodCaller <ProtectedStatic_string>(typeof(TestClass), "ProtectedStatic");
XAssert.NotNull(dg);
// Case-sensitive name - should fail
XAssert.Throws <MissingMethodException>(() => MR.GetMethodCaller <ProtectedStatic_string>(typeof(TestClass), "protectedstatic"));
// Case-insensitive name
dg = MR.GetMethodCaller <ProtectedStatic_string>(typeof(TestClass), "protectedstatic", true);
XAssert.NotNull(dg);
}
public void GetAllBannersTest()
{
BannerContext context = new BannerContext(new DbContextOptionsBuilder <BannerContext>().UseInMemoryDatabase(databaseName: "BannerItemsTest3").Options);
var testBanners = TestBanners();
context.Banners.AddRange(testBanners);
context.SaveChanges();
var bannerService = new BannerService(context);
var actual = bannerService.GetAllBanners();
var expected = testBanners;
Assert.NotNull(actual);
Assert.Equal(expected, actual);
}
public void TwoLanguages()
{
var key = new TypePromptKey(typeof(TestType).FullName, "FirstName");
_repository.Save(new CultureInfo(1033), typeof(TestType).FullName, "FirstName", "FirstName");
_repository.Save(new CultureInfo(1053), typeof(TestType).FullName, "FirstName", "Förnamn");
var enprompt = _repository.GetPrompt(new CultureInfo(1033), key);
var seprompt = _repository.GetPrompt(new CultureInfo(1053), key);
Assert.NotNull(enprompt);
Assert.NotNull(seprompt);
Assert.NotEqual(enprompt.TranslatedText, seprompt.TranslatedText);
}
public void ProtectedInstance_ExplicitName()
{
MethodInfo methodInfo = null;
// Case-sensitive name
methodInfo = MR.GetMethodInfo <ProtectedInstance_int>(typeof(TestClass), "ProtectedInstance", false);
XAssert.NotNull(methodInfo);
// Case-sensitive name - should fail
XAssert.Throws <MissingMethodException>(() => MR.GetMethodInfo <ProtectedInstance_int>(typeof(TestClass), "protectedinstance", false));
// Case-insensitive name
methodInfo = MR.GetMethodInfo <ProtectedInstance_int>(typeof(TestClass), "protectedinstance", false, true);
XAssert.NotNull(methodInfo);
}
public void AfterSourceUpdate()
{
Bindings.Property(Model, x => x.Name).To(Control.TextProperty())
.AfterSourceUpdate((binding, s) =>
{
Target = (IProperty <string>)binding.Target;
Source = (IProperty <string>)binding.Source;
});
Bindings.Bind();
Control.Text = "Hello World";
Assert.NotNull(Target);
Assert.NotNull(Source);
}
public void RegisterTickerMustBeAdded()
{
//Arrange
var ticket = _databaseFixture.CreateRegistrationTicket();
//Act
_databaseFixture.DatabaseAdapter.WriteRegistrationTicket(ticket);
var ticketFromDB = _databaseFixture.DatabaseAdapter.ReadRegistrationTicket(ticket.Id);
//Assert
Assert.NotNull(ticketFromDB);
Assert.Equal(ticket.Id, ticketFromDB.Id);
Assert.Equal(ticket.Role, ticketFromDB.Role);
Assert.Equal(ticket.ProductKey, ticketFromDB.ProductKey);
Assert.Equal(ticket.ExpirationDate, ticketFromDB.ExpirationDate);
}
public async Task JournaledGrainTests_AppendMoreEvents()
{
var leia = GrainClient.GrainFactory.GetGrain <IPersonGrain>(Guid.NewGuid());
await leia.RegisterBirth(new PersonAttributes { FirstName = "Leia", LastName = "Organa", Gender = GenderType.Female });
var han = GrainClient.GrainFactory.GetGrain <IPersonGrain>(Guid.NewGuid());
await han.RegisterBirth(new PersonAttributes { FirstName = "Han", LastName = "Solo", Gender = GenderType.Male });
await leia.Marry(han);
var attributes = await leia.GetTentativePersonalAttributes();
Assert.NotNull(attributes);
Assert.Equal("Leia", attributes.FirstName);
Assert.Equal("Solo", attributes.LastName);
}
public async void GetRoomPricesTest()
{
var result = await _tenantRepository.GetRoomPricesAsync(1, _tenantId);
Assert.NotNull(result);
Assert.Equal(3, result.Count);
Assert.Equal(1, result[0].RoomId);
Assert.Equal(1, result[0].HotelId);
Assert.Equal(100, result[0].Price);
Assert.Equal(1, result[1].RoomId);
Assert.Equal(2, result[1].HotelId);
Assert.Equal(80, result[1].Price);
Assert.Equal(1, result[2].RoomId);
Assert.Equal(3, result[2].HotelId);
Assert.Equal(60, result[2].Price);
}
public async Task WhenTheCallIsSuccessfulThenWeShouldReceiveAListOfStrings()
{
var handler = FakeHttpMessageHandler.NewMock();
string jsonData = @"{'City': 'Dublin'}";
handler.SetupSuccessfulCall(new List <string> {
jsonData
});
var client = HttpClientHelper.NewTestClient(handler.Object);
var proxy = new ApiProxyTestClass(client);
var result = (await proxy.GetLocationAsync(client.BaseAddress.ToString()));
Assert.Contains("Dublin", result.ToString());
Assert.NotNull(result);
}
public void PrivateInstance_ExplicitName()
{
PrivateInstance_int dg = null;
TestClass instance = new TestClass(THE_NAME);
// Case-sensitive name
dg = MR.GetMethodCaller <PrivateInstance_int>(instance, typeof(TestClass), "PrivateInstance");
XAssert.NotNull(dg);
// Case-sensitive name - should fail
XAssert.Throws <MissingMethodException>(() => MR.GetMethodCaller <PrivateInstance_int>(instance, typeof(TestClass), "privateinstance"));
// Case-insensitive name
dg = MR.GetMethodCaller <PrivateInstance_int>(instance, typeof(TestClass), "privateinstance", true);
XAssert.NotNull(dg);
}
public async Task GetTopStreams(string gameName)
{
var topStreamsQuery = new TopStreamQuery()
{
Skip = 0, Take = 100, GameName = gameName
};
var topStreams = await sut.GetTopStreams(topStreamsQuery);
Assert.NotNull(topStreams);
Assert.NotEmpty(topStreams);
if (topStreamsQuery.GameName != null)
{
Assert.All(topStreams, stream => Assert.Contains(topStreamsQuery.GameName, stream.Game, StringComparison.OrdinalIgnoreCase));
}
}
public void ConfigurationObjectMustBeUpdated()
{
//Arrange
var configObj = _databaseFixture.CreateConfigurationObject();
//Act
_databaseFixture.DatabaseAdapter.WriteConfigurationObject(configObj);
string newValue = "New value";
configObj.Value = newValue;
_databaseFixture.DatabaseAdapter.WriteConfigurationObject(configObj);
var objectFromDB = _databaseFixture.DatabaseAdapter.GetConfigurationObject(configObj.Name);
//Assert
Assert.NotNull(objectFromDB);
Assert.Equal(newValue, objectFromDB.Value);
}
public void SaveMockDefinitionSuccessTest()
{
#region Test Setup
var options = new MemoryCacheOptions();
var cache = new MemoryCache(options);
#endregion
var mockDefinition = mockDefinitionFake.Generate();
var saveMockDefinitionCommand = new SaveMockDefinitionCommand(mockDefinition, ref TestUtils.databaseLock);
var Target = new SaveMockDefinitionHandler(cache, data);
Target.Handle(saveMockDefinitionCommand, CancellationToken.None).Result.ToString();
cache.TryGetValue(mockDefinition.Metadata.Title, out var savedDefinition);
Assert.NotNull(savedDefinition);
}
public void GetSaleModelEmptyTest()
{
var id = Guid.NewGuid();
// Arrange
var mockRepository = new Mock <IStorage <SaleModel> >();
mockRepository.Setup(x => x.GetAll()).Returns(new List <SaleModel>());
var controller = new SaleAPIController(mockRepository.Object);
// Act
var actionResult = controller.GetSaleModel() as List <SaleModel>;
// Assert
Assert.NotNull(actionResult);
CollectionAssert.IsEmpty(actionResult);
// CollectionAssert.AllItemsAreInstancesOfType(actionResult, SaleModel);
}
private async ThreadingTask RunPluginVersioningTest <TFirstPlugin, TSecondPlugin>(bool shouldSucceed)
where TSecondPlugin : Workflow, new()
where TFirstPlugin : Workflow, new()
{
_fixture.Container.RegisterInstance(GetServiceProvider(), new PerThreadLifetimeManager());
_fixture.Container.RegisterType <IWorkflowContainer <TFirstPlugin, ExternalDataHandlerTaskOutput>, WorkflowContainer <TFirstPlugin, ExternalDataHandlerTaskOutput> >();
_fixture.Container.RegisterType <IWorkflowContainer <TSecondPlugin, ExternalDataHandlerTaskOutput>, WorkflowContainer <TSecondPlugin, ExternalDataHandlerTaskOutput> >();
var firstPluginContainer = _fixture.Container.Resolve <IWorkflowContainer <TFirstPlugin, ExternalDataHandlerTaskOutput> >();
firstPluginContainer.Initialize();
var workflowInput = firstPluginContainer.CreateWorkflowInput <ExternalAnswerWorkflowInput>();
workflowInput.Data.Question = "2+2";
// First execution. External dependencies won't be resolved
var result = await firstPluginContainer.Execute(new PluginInputs { { "input", workflowInput } });
var workflowOutput = firstPluginContainer.GetOutput();
Assert.Null(workflowOutput);
Assert.True(result == WorkflowContainerExecutionResult.PartiallyCompleted);
// Store Context and recreate workflow container
var serializedWorkflowContext = firstPluginContainer.Store();
var secondPluginContainer = _fixture.Container.Resolve <IWorkflowContainer <TSecondPlugin, ExternalDataHandlerTaskOutput> >();
var loadSucceeded = secondPluginContainer.TryLoad(serializedWorkflowContext);
Assert.True(loadSucceeded);
// Second execution. External dependencies will be resolved
result = await secondPluginContainer.ReExecute();
workflowOutput = secondPluginContainer.GetOutput();
if (shouldSucceed)
{
Assert.NotNull(workflowOutput);
Assert.True(result == WorkflowContainerExecutionResult.Completed);
}
else
{
Assert.Null(workflowOutput);
Assert.True(result == WorkflowContainerExecutionResult.NotExecuted);
}
}
public void UsersPageMustBeRead()
{
//Arrange
var user1 = _databaseFixture.CreateFirstUser();
var user2 = _databaseFixture.CreateSecondUser();
var user3 = _databaseFixture.CreateThirdUser();
//Act
_databaseFixture.DatabaseAdapter.AddUser(user1);
_databaseFixture.DatabaseAdapter.AddUser(user2);
_databaseFixture.DatabaseAdapter.AddUser(user3);
var page = _databaseFixture.DatabaseAdapter.GetUsersPage(2, 1);
//Assert
Assert.NotNull(page);
Assert.Equal(1, page.Count);
}
public void UsersEmptyPageMustBeReturned()
{
//Arrange
var user1 = _databaseFixture.CreateFirstUser();
var user2 = _databaseFixture.CreateSecondUser();
var user3 = _databaseFixture.CreateThirdUser();
//Act
_databaseFixture.DatabaseAdapter.AddUser(user1);
_databaseFixture.DatabaseAdapter.AddUser(user2);
_databaseFixture.DatabaseAdapter.AddUser(user3);
var page = _databaseFixture.DatabaseAdapter.GetUsersPage(3, 5);
//Assert
Assert.NotNull(page);
Assert.Empty(page);
}
public void FromAttachToDettach()
{
var page = new ContentPage();
var contextObject = new object();
page.BindingContext = contextObject;
var behavior = new BehaviorMock();
page.Behaviors.Add(behavior);
Assert.NotNull(behavior.BindingContext);
Assert.Equal(contextObject, behavior.BindingContext);
page.Behaviors.Clear();
Assert.Null(behavior.BindingContext);
}
public void Login_InvalidCredentialsRedisplaysLoginScreen()
{
string returnUrl = "/Home/Index";
string userName = "******";
string password = "******";
WebSecurity.Setup(s => s.Login(userName, password, false)).Returns(false);
var model = new LoginModel
{
UserName = userName,
Password = password
};
var result = Controller.Login(model, returnUrl) as ViewResult;
Assert.True(Controller.ModelState.Count == 1, "ModelState Values");
Assert.NotNull(result);
}
public void TestCreatePsd2Context()
{
ApiContext apiContext = null;
if (File.Exists(FILE_TEST_CONFIGURATION))
{
apiContext = ApiContext.Restore(FILE_TEST_CONFIGURATION);
Assert.NotNull(apiContext);
BunqContext.LoadApiContext(apiContext);
return;
}
apiContext = CreateApiContext();
BunqContext.LoadApiContext(apiContext);
Assert.True(File.Exists(FILE_TEST_CONFIGURATION));
}
public void TestCreateOauthClient()
{
if (File.Exists(FILE_TEST_OAUTH))
{
return;
}
int clientId = OauthClient.Create().Value;
OauthClient oauthClient = OauthClient.Get(clientId).Value;
Assert.NotNull(oauthClient);
File.WriteAllText(
FILE_TEST_OAUTH,
BunqJsonConvert.SerializeObject(oauthClient)
);
Assert.True(File.Exists(FILE_TEST_OAUTH));
}
public void Login_UserCanLogin()
{
string returnUrl = "/Home/Index";
string userName = "******";
string password = "******";
WebSecurity.Setup(s => s.Login(userName, password, false)).Returns(true);
var model = new LoginModel
{
UserName = userName,
Password = password
};
var result = Controller.Login(model, returnUrl) as RedirectResult;
Assert.NotNull(result);
Assert.Equal(returnUrl, result.Url);
}
public void ProductMustBeRemoved()
{
//Arrange
var product = _databaseFixture.GetSecondTestProduct();
//Act
_databaseFixture.DatabaseAdapter.AddProduct(product);
//Assert
Assert.NotNull(_databaseFixture.DatabaseAdapter.GetProduct(_databaseFixture.SecondProductName));
//Act
_databaseFixture.DatabaseAdapter.RemoveProduct(product.Name);
var correspondingProduct = _databaseFixture.DatabaseAdapter.GetProduct(product.Name);
//Assert
Assert.Null(correspondingProduct);
}
public void PrivateStatic_ExplicitName()
{
PrivateStatic_int dg = null;
string lConst3 = TestClass.StringConstant + TestClass.StringConstant + TestClass.StringConstant;
// Case-sensitive name
dg = MR.GetMethodCaller <PrivateStatic_int>(typeof(TestClass), "PrivateStatic");
XAssert.NotNull(dg);
XAssert.Equal(lConst3, dg(3));
// Case-sensitive name - should fail
XAssert.Throws <MissingMethodException>(() => MR.GetMethodCaller <PrivateStatic_int>(typeof(TestClass), "privatestatic"));
// Case-insensitive name
dg = MR.GetMethodCaller <PrivateStatic_int>(typeof(TestClass), "privatestatic", true);
XAssert.NotNull(dg);
XAssert.Equal(lConst3, dg(3));
}
public void ProtectedStatic_RefParam()
{
// Signature with normal param should not match signature with ref param
XAssert.Throws <MissingMethodException>(() => MR.GetMethodCaller <ProtectedStatic_int>(typeof(TestClass), "ProtectedStatic"));
// Signature with out param should not match signature with ref param
XAssert.Throws <MissingMethodException>(() => MR.GetMethodCaller <ProtectedStatic_outint>(typeof(TestClass), "ProtectedStatic"));
// Match on ref
var dg = MR.GetMethodCaller <ProtectedStatic_refint>(typeof(TestClass), "ProtectedStatic");
XAssert.NotNull(dg);
int val = 0;
dg(ref val);
XAssert.Equal(42, val);
}
public void Test()
{
var expectedMetrics = new List <Assertions.ExpectedMetric>
{
new Assertions.ExpectedMetric {
metricName = @"MessageBroker/NServiceBus/Queue/Consume/Named/NServiceBusReceiver.SampleNServiceBusMessage2"
},
new Assertions.ExpectedMetric {
metricName = @"MessageBroker/NServiceBus/Queue/Consume/Named/NServiceBusReceiver.SampleNServiceBusMessage2",
metricScope = @"OtherTransaction/Message/NServiceBus/Queue/Named/NServiceBusReceiver.SampleNServiceBusMessage2"
},
new Assertions.ExpectedMetric {
metricName = @"OtherTransaction/Message/NServiceBus/Queue/Named/NServiceBusReceiver.SampleNServiceBusMessage2"
},
new Assertions.ExpectedMetric {
metricName = @"OtherTransactionTotalTime/Message/NServiceBus/Queue/Named/NServiceBusReceiver.SampleNServiceBusMessage2"
}
};
var expectedTransactionTraceSegments = new List <string>
{
@"MessageBroker/NServiceBus/Queue/Consume/Named/NServiceBusReceiver.SampleNServiceBusMessage2"
};
var metrics = _fixture.AgentLog.GetMetrics().ToList();
var transactionSample = _fixture.AgentLog.TryGetTransactionSample("OtherTransaction/Message/NServiceBus/Queue/Named/NServiceBusReceiver.SampleNServiceBusMessage2");
var transactionEvent = _fixture.AgentLog.TryGetTransactionEvent("OtherTransaction/Message/NServiceBus/Queue/Named/NServiceBusReceiver.SampleNServiceBusMessage2");
var errorTrace =
_fixture.AgentLog.TryGetErrorTrace(
"OtherTransaction/Message/NServiceBus/Queue/Named/NServiceBusReceiver.SampleNServiceBusMessage2");
NrAssert.Multiple(
() => Assert.NotNull(transactionSample),
() => Assert.NotNull(transactionEvent),
() => Assert.NotNull(errorTrace)
);
NrAssert.Multiple
(
() => Assertions.MetricsExist(expectedMetrics, metrics),
() => Assertions.TransactionTraceSegmentsExist(expectedTransactionTraceSegments, transactionSample)
);
}
public void MockServerProcessorPushWithInvalidJsonFailure()
{
#region TestSetup
var scenarios = this.fakerScenario.Generate(1);
var httpContext = new DefaultHttpContext();
httpContext.Request.Path = scenarios[0].Path;
httpContext.Request.Method = scenarios[0].Verb.ToString();
httpContext.Request.Body = new MemoryStream(Encoding.ASCII.GetBytes("invalid \\json"));
scenarios[0].RequestMatchRules.HeaderRules.ToList().ForEach(k => httpContext.Request.Headers.Add(k.RuleValue.Key, k.RuleValue.Value));
httpContext.Request.Query = new QueryCollection(scenarios[0].RequestMatchRules.QueryRules.ToDictionary(x => x.RuleValue.Key, x => new StringValues(x.RuleValue.Value)));
var input = new MessageProcessorInput(httpContext.Request, scenarios);
#endregion
var Target = this.mockServerProcessor;
Target.Start();
var Actual = Target.Push(input, cancellationToken);
Assert.NotNull(Actual.Result.Body);
}
public void ProtectedInstance_ExplicitName()
{
ProtectedInstance_int dg = null;
TestClass instance = new TestClass(THE_NAME);
string lExpected = THE_NAME + TestClass.StringConstant + TestClass.StringConstant + TestClass.StringConstant;
// Case-sensitive name
dg = MR.GetMethodCaller <ProtectedInstance_int>(instance, typeof(TestClass), "ProtectedInstance");
XAssert.NotNull(dg);
XAssert.Equal(lExpected, dg(3));
// Case-sensitive name - should fail
XAssert.Throws <MissingMethodException>(() => MR.GetMethodCaller <ProtectedInstance_int>(typeof(TestClass), "protectedinstance"));
// Case-insensitive name
dg = MR.GetMethodCaller <ProtectedInstance_int>(instance, typeof(TestClass), "protectedinstance", true);
XAssert.NotNull(dg);
XAssert.Equal(lExpected, dg(3));
}
public async Task Execute_GivenWeeeReceivedData_ReturnsWeeeReceivedAatfDataShouldBeCorrect()
{
using (var db = new DatabaseWrapper())
{
var @return = CreateSubmittedReturn(db);
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(db, @return.Organisation);
var scheme = ObligatedWeeeIntegrationCommon.CreateScheme(@return.Organisation);
scheme.UpdateScheme("TestScheme", "WEE/AB1234CD/SCH", string.Empty, null, aatf.CompetentAuthority);
var weeeReceived = new EA.Weee.Domain.AatfReturn.WeeeReceived(scheme, aatf, @return);
var weeeReceivedAmounts = new List <WeeeReceivedAmount>()
{
new Domain.AatfReturn.WeeeReceivedAmount(weeeReceived, 1, 1, 2),
new Domain.AatfReturn.WeeeReceivedAmount(weeeReceived, 2, 3, 4)
};
db.WeeeContext.Returns.Add(@return);
db.WeeeContext.ReturnAatfs.Add(new ReturnAatf(aatf, @return));
db.WeeeContext.WeeeReceived.Add(weeeReceived);
db.WeeeContext.WeeeReceivedAmount.AddRange(weeeReceivedAmounts);
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetAatfObligatedCsvData(@return.Id, 2019, 1, aatf.Id);
Assert.NotNull(results);
var data = from x in results.AsEnumerable()
where x.Field <string>("Name of AATF") == aatf.Name
select x;
data.AsQueryable().Count().Should().Be(28);
var dataB2B = from x in results.AsEnumerable()
where x.Field <string>("Name of AATF") == aatf.Name && x.Field <string>("Obligation type") == "B2B"
select x;
dataB2B.AsQueryable().Count().Should().Be(14);
var dataB2C = from x in results.AsEnumerable()
where x.Field <string>("Name of AATF") == aatf.Name && x.Field <string>("Obligation type") == "B2C"
select x;
dataB2C.AsQueryable().Count().Should().Be(14);
}
}
