public void WhenInvalidModelContainsOneError()
{
var distributedCacheMock = new Mock <IDistributedCache>();
var certificatePrivateStandardCodeController =
new CertificatePrivateStandardCodeController(MockLogger.Object,
MockHttpContextAccessor.Object,
new CacheService(distributedCacheMock.Object),
MockApiClient,
MockStandardServiceClient.Object, MockOrganisationsApiClient);
var vm = new CertificateStandardCodeListViewModel
{
Id = Certificate.Id,
FullName = "James Corley",
SelectedStandardCode = "93",
IsPrivatelyFunded = true,
ReasonForChange = "Required reason for change"
};
MockSession.Setup(q => q.Get("EndPointAsessorOrganisationId"))
.Returns("EPA00001");
// view model validation errors will not be trigged as they are attached via fluent
// validation and these are not connected in tests however this test is actually testing
// the correct view is returned so the actual error is irrelevant and can be forced
certificatePrivateStandardCodeController.ModelState.AddModelError("", "Error");
var result = certificatePrivateStandardCodeController.StandardCode(vm).GetAwaiter().GetResult();
_result = result as ViewResult;
}
public void CreateClient_Should_Create_SessionAWSCredentials_With_AwsAccessKeyId_And_AwsAccessKey_And_AwsSessionToken()
{
MockSession mockSession = MockSession.Create();
IServiceMetadata mockServiceMetadata = new MockServiceMetadata();
var mockAwsServiceEndpoint = new MockAwsServiceEndpoint();
var mockClientConfig = new MockClientConfig();
const string awsAccessKeyId = "AwsAccessKeyId";
const string awsAccessKey = "AwsAccessKey";
const string awsSessionToken = "AwsSessionToken";
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKeyId).Returns(awsAccessKeyId);
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKey).Returns(awsAccessKey);
mockSession.SessionOptionsMock.SetupGet(options => options.AwsSessionToken).Returns(awsSessionToken);
mockSession.SessionReflectionMock.Setup(reflection => reflection.ExtractServiceMetadata <MockAmazonServiceClient>()).Returns(() => mockServiceMetadata);
mockSession.SessionReflectionMock.Setup(reflection => reflection.CreateClientConfig <MockAmazonServiceClient>()).Returns(() => mockClientConfig);
mockSession.SessionReflectionMock.Setup(reflection => reflection.SetForcePathStyle(mockClientConfig, true)).Returns(() => true);
mockSession.ConfigMock.Setup(config => config.GetAwsServiceEndpoint(It.IsAny <string>())).Returns(() => mockAwsServiceEndpoint);
var mockAmazonServiceClient = mockSession.CreateClient <MockAmazonServiceClient>();
Assert.NotNull(mockAmazonServiceClient);
AWSCredentials awsCredentials = mockAmazonServiceClient.AwsCredentials;
Assert.NotNull(awsCredentials);
Assert.IsType <SessionAWSCredentials>(awsCredentials);
var sessionAwsCredentials = (SessionAWSCredentials)awsCredentials;
ImmutableCredentials immutableCredentials = sessionAwsCredentials.GetCredentials();
Assert.Equal(awsAccessKeyId, immutableCredentials.AccessKey);
Assert.Equal(awsAccessKey, immutableCredentials.SecretKey);
Assert.Equal(awsSessionToken, immutableCredentials.Token);
}
public void WhenValidModelContainsNoErrors()
{
var distributedCacheMock = new Mock <IDistributedCache>();
var certificatePrivateStandardCodeController =
new CertificatePrivateStandardCodeController(MockLogger.Object,
MockHttpContextAccessor.Object,
new CacheService(distributedCacheMock.Object),
MockApiClient,
MockStandardServiceClient.Object, MockOrganisationsApiClient
);
var vm = new CertificateStandardCodeListViewModel
{
Id = Certificate.Id,
FullName = "James Corley",
SelectedStandardCode = "93",
IsPrivatelyFunded = true,
ReasonForChange = "Required reason for change"
};
MockSession.Setup(q => q.Get("EndPointAsessorOrganisationId"))
.Returns("EPA00001");
var result = certificatePrivateStandardCodeController.StandardCode(vm).GetAwaiter().GetResult();
_result = result as RedirectToActionResult;
}
public void CreateClient_Should_Create_AmazonServiceClient_By_Given_Generic_Type()
{
MockSession mockSession = MockSession.Create();
IServiceMetadata mockServiceMetadata = new MockServiceMetadata();
var mockAwsServiceEndpoint = new MockAwsServiceEndpoint();
var mockClientConfig = new MockClientConfig();
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKeyId).Returns("AwsAccessKeyId");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKey).Returns("AwsAccessKey");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsSessionToken).Returns("AwsSessionToken");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKeyId).Returns("AwsAccessKeyId");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKey).Returns("AwsAccessKey");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsSessionToken).Returns("AwsSessionToken");
mockSession.SessionReflectionMock.Setup(reflection => reflection.ExtractServiceMetadata <MockAmazonServiceClient>()).Returns(() => mockServiceMetadata);
mockSession.SessionReflectionMock.Setup(reflection => reflection.CreateClientConfig <MockAmazonServiceClient>()).Returns(() => mockClientConfig);
mockSession.SessionReflectionMock.Setup(reflection => reflection.SetForcePathStyle(mockClientConfig, true)).Returns(() => true);
mockSession.ConfigMock.Setup(config => config.GetAwsServiceEndpoint(It.IsAny <string>())).Returns(() => mockAwsServiceEndpoint);
var mockAmazonServiceClient = mockSession.CreateClient <MockAmazonServiceClient>();
Assert.NotNull(mockAmazonServiceClient);
mockSession.ConfigMock.Verify(config => config.GetAwsServiceEndpoint(It.Is <string>(serviceId => serviceId == mockServiceMetadata.ServiceId)), Times.Once);
mockSession.SessionReflectionMock.Verify(reflection => reflection.ExtractServiceMetadata <MockAmazonServiceClient>(), Times.Once);
mockSession.SessionReflectionMock.Verify(reflection => reflection.CreateClientConfig <MockAmazonServiceClient>(), Times.Once);
mockSession.SessionReflectionMock.Verify(reflection => reflection.SetForcePathStyle(It.Is <ClientConfig>(config => config == mockClientConfig), true),
Times.Once);
}
public MockHttpContext()
{
ConnectionInfoMock = new Mock <ConnectionInfo>();
HttpResponseMock = new Mock <HttpResponse>();
HttpRequestMock = new Mock <HttpRequest>();
ServiceProviderMock = new Mock <IServiceProvider>();
Items = new Dictionary <object, object>();
Session = new MockSession();
HttpResponseMock
.SetupSet(m => m.StatusCode = It.IsAny <int>())
.Callback <int>(code => _statusCode = code);
ServiceProviderMock
.Setup(m => m.GetService(typeof(ITempDataDictionaryFactory)))
.Returns(new MockTempDataDictionaryFactory());
ServiceProviderMock
.Setup(m => m.GetService(typeof(IUrlHelperFactory)))
.Returns(new Mock <IUrlHelperFactory>().Object);
HttpRequestMock
.Setup(m => m.Headers)
.Returns(new MockHeaderDictionary());
HttpResponseMock
.Setup(m => m.Headers)
.Returns(new MockHeaderDictionary());
HttpResponseMock
.Setup(m => m.Redirect(It.IsAny <string>()))
.Callback <string>(u => _actualRedirectUrl = u);
}
public void Arrange()
{
var distributedCacheMock = new Mock <IDistributedCache>();
var certificatePrivateStandardCodeController =
new CertificatePrivateStandardCodeController(MockLogger.Object,
MockHttpContextAccessor.Object,
MockOrganisationApiClient,
new CacheHelper(distributedCacheMock.Object),
MockCertificateApiClient,
MockSession.Object,
MockStandardServiceClient.Object
);
var vm = new CertificateStandardCodeListViewModel
{
Id = Certificate.Id,
FullName = "James Corley",
SelectedStandardCode = "93",
IsPrivatelyFunded = true
};
SetupSession();
MockSession.Setup(q => q.Get("EndPointAsessorOrganisationId"))
.Returns("EPA00001");
certificatePrivateStandardCodeController.ModelState.AddModelError("", "Error");
var result = certificatePrivateStandardCodeController.StandardCode(vm).GetAwaiter().GetResult();
_result = result as ViewResult;
}
public void CreateClient_Should_Create_ClientConfig_With_ServiceURL_UseHttp_ProxyHost_ProxyPort()
{
MockSession mockSession = MockSession.Create();
IServiceMetadata mockServiceMetadata = new MockServiceMetadata();
var mockAwsServiceEndpoint = new MockAwsServiceEndpoint();
var mockClientConfig = new MockClientConfig();
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKeyId).Returns("AwsAccessKeyId");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsAccessKey).Returns("AwsAccessKey");
mockSession.SessionOptionsMock.SetupGet(options => options.AwsSessionToken).Returns("AwsSessionToken");
mockSession.SessionReflectionMock.Setup(reflection => reflection.ExtractServiceMetadata <MockAmazonServiceClient>()).Returns(() => mockServiceMetadata);
mockSession.SessionReflectionMock.Setup(reflection => reflection.CreateClientConfig <MockAmazonServiceClient>()).Returns(() => mockClientConfig);
mockSession.SessionReflectionMock.Setup(reflection => reflection.SetForcePathStyle(mockClientConfig, true)).Returns(() => true);
mockSession.ConfigMock.Setup(config => config.GetAwsServiceEndpoint(It.IsAny <string>())).Returns(() => mockAwsServiceEndpoint);
var mockAmazonServiceClient = mockSession.CreateClient <MockAmazonServiceClient>();
Assert.NotNull(mockAmazonServiceClient);
IClientConfig clientConfig = mockAmazonServiceClient.Config;
Assert.Equal(mockAwsServiceEndpoint.ServiceUrl, clientConfig.ServiceURL);
Assert.True(clientConfig.UseHttp);
Assert.Equal(mockAwsServiceEndpoint.Host, clientConfig.ProxyHost);
Assert.Equal(mockAwsServiceEndpoint.Port, clientConfig.ProxyPort);
}
public SessionTest()
{
this._dummyContext = new DummyApplicationDbContext();
this._sessionRepository = new Mock <IBoBSessionRepository>();
this._mockHttp = new Mock <HttpContext>();
this._mockSession = new MockSession();
this._controller = new MockSessionController(_sessionRepository.Object, _mockHttp.Object);
}
public BoltTestHarness()
{
MockSession.Setup(s => s.Run("CALL dbms.components()")).Returns(new Extensions.BoltGraphClientTests.ServerInfo());
MockDriver.Setup(d => d.Session(It.IsAny <AccessMode>())).Returns(MockSession.Object);
MockDriver.Setup(d => d.Session(It.IsAny <AccessMode>(), It.IsAny <IEnumerable <string> >())).Returns(MockSession.Object);
MockDriver.Setup(d => d.Session(It.IsAny <IEnumerable <string> >())).Returns(MockSession.Object);
MockDriver.Setup(d => d.Uri).Returns(new Uri("bolt://localhost"));
}
protected override void Given()
{
projectToAdd = new Project();
session = new MockSession();
SUT = new CreateOrUpdateProjectValidation(session);
projectToAdd.Name = ExistingProject;
}
public void GetMenuListSelf()
{
var mgr = new UserMgr();
MockSession.NewHttpContextBase();
ContextObjects.CurrentUser = mgr.Login("admin", "1");
var res = MenuActionMgr.GetMenuListSelf();
Assert.IsNotNull(res);
}
public void CreateClient_Should_Throw_InvalidOperationException_If_Given_ServiceId_Is_Not_Supported()
{
MockSession mockSession = MockSession.Create();
IServiceMetadata mockServiceMetadata = new MockServiceMetadata();
mockSession.SessionReflectionMock.Setup(reflection => reflection.ExtractServiceMetadata <MockAmazonServiceClient>()).Returns(() => mockServiceMetadata);
mockSession.ConfigMock.Setup(config => config.GetAwsServiceEndpoint(It.IsAny <string>())).Returns(() => null);
Assert.Throws <InvalidOperationException>(() => mockSession.CreateClient <MockAmazonServiceClient>());
mockSession.ConfigMock.Verify(config => config.GetAwsServiceEndpoint(It.Is <string>(serviceId => serviceId == mockServiceMetadata.ServiceId)), Times.Once);
}
public void AddFriendSuccessful()
{
var mockContext = new Mock <HttpContext>();
var mockSession = new MockSession();
mockSession.SetString("email", "*****@*****.**");
mockContext.Setup(s => s.Session).Returns(mockSession);
controller.ControllerContext.HttpContext = mockContext.Object;
var userId = User.GetUserByEmail("*****@*****.**").Id.ToString();
var result = controller.AddFriend("*****@*****.**", userId) as RedirectResult;
Assert.That(result.Url, Does.Contain($"/User/{userId}"));
}
public void AcceptFriendSuccessful()
{
var mockContext = new Mock <HttpContext>();
var mockSession = new MockSession();
mockSession.SetString("email", "*****@*****.**");
mockContext.Setup(s => s.Session).Returns(mockSession);
controller.ControllerContext.HttpContext = mockContext.Object;
var friendRequests = Friend.GetIncomingRequest("*****@*****.**");
var result = controller.AcceptFriend(friendRequests[0].Id.ToString()) as OkResult;
Assert.AreEqual(200, result.StatusCode);
}
private void AddMockSessionToController(StoreController controller, ShoppingCart cart)
{
// Mock Session Object
MockSession mockSession = new MockSession();
mockSession["ShoppingCart"] = cart;
// Mock Http Context Request for Controller
// because Session doesn't exist unless MVC actually receives a "request"
Mock <HttpContextBase> mockContext = new Mock <HttpContextBase>();
// When the Controller calls this.Session it will get a mock session
mockContext.Setup(c => c.Session).Returns(mockSession);
// Assign the context property on the controller to our mock context which uses our mock session
controller.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), controller);
// For more details:
// https://dontpaniclabs.com/blog/post/2011/03/22/testing-session-in-mvc-in-four-lines-of-code/
}
public void Arrange()
{
Mock <IDistributedCache> mockDistributedCache = new Mock <IDistributedCache>();
var certificatePrivateStandardCodeController =
new CertificatePrivateStandardCodeController(MockLogger.Object,
MockHttpContextAccessor.Object,
MockOrganisationApiClient,
new CacheHelper(mockDistributedCache.Object),
MockCertificateApiClient,
MockSession.Object,
MockStandardServiceClient.Object
);
MockSession.Setup(q => q.Get("EndPointAsessorOrganisationId"))
.Returns("EPA00001");
var result = certificatePrivateStandardCodeController.StandardCode(false).GetAwaiter().GetResult();
_result = result as RedirectToActionResult;
}
public void Before()
{
session = new MockSession(new TestApp());
}
private static NHibernateDataProvider GetMockProvider(MockTransaction mockTransaction)
{
var mockSession = new MockSession(mockTransaction);
var mockSessionFactory = new MockSessionFactory(mockSession);
return new NHibernateDataProvider(mockSession);
}
