public void UnknownApplication()
{
var controller = new AuthorizeController(null, _testConfig);
var result = controller.Index("unknown", null);
Assert.IsTrue(result is HttpNotFoundResult);
}
public void AuthorizeControllerTest()
{
var controller = new AuthorizeController(_mock.Object);
Assert.IsNotNull(controller);
Assert.IsInstanceOfType(controller, typeof(AuthorizeController));
}
public void AuthorizeGetTest()
{
var authorizeController = new AuthorizeController();
var login = authorizeController.Authenticate("*****@*****.**", "password");
Assert.AreEqual("1", login.Id);
}
private void InitializeController()
{
this.mockAppConfig = new Mock <AppConfig> {
DefaultValue = DefaultValue.Mock
};
this.logger = new Mock <ILogger <UserTenantContainer> >();
this.mockUserTenantContainer = new Mock <UserTenantContainer>(this.logger.Object);
this.mockUserSettingsContainer = new Mock <IUserContainer <UserSettingsModel, UserSettingsInput> >();
this.mockJwtHelper = new Mock <IJwtHelpers> {
DefaultValue = DefaultValue.Mock
};
this.mockAuthContext = new Mock <IAuthenticationContext> {
DefaultValue = DefaultValue.Mock
};
this.mockHttpContext = new Mock <HttpContext> {
DefaultValue = DefaultValue.Mock
};
this.mockOpenIdProviderConfiguration = new Mock <IOpenIdProviderConfiguration> {
DefaultValue = DefaultValue.Mock
};
this.controller = new AuthorizeController(this.mockAppConfig.Object, this.mockUserTenantContainer.Object, this.mockUserSettingsContainer.Object as UserSettingsContainer, this.mockJwtHelper.Object, this.mockOpenIdProviderConfiguration.Object, this.mockAuthContext.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = this.mockHttpContext.Object,
},
};
}
public void AuthorizePostTest()
{
var authorizeController = new AuthorizeController();
var login = authorizeController.Authenticate(new Logon {
UserName = "******", Password = "******"
});
Assert.AreEqual("1", login.Id);
}
public async Task Logout_CorrectLogout_ReturnsOk()
{
var authorizatorMock = new Mock <IAuthorizator>().Object;
var reCaptcha = new Mock <IReCaptcha>().Object;
var controller = new AuthorizeController(reCaptcha, authorizatorMock);
var result = await controller.Logout();
result.Should().BeOfType <OkResult>();
}
public async Task Login_UserNotExists_ReturnsBadRequest()
{
var authorizatorMock = new Mock <IAuthorizator>().Object;
var reCaptcha = new Mock <IReCaptcha>().Object;
var controller = new AuthorizeController(reCaptcha, authorizatorMock);
var result = await controller.Login(new LoginParameters());
(result as BadRequestObjectResult).Value.Should().Be("User does not exist");
}
public async Task Login_IncorrectLogin()
{
var userManager = GetUserManager();
var signInManager = GetSignInManager(SignInIncorrectLogin);
var jwtSettings = JwtSettings;
var loginController = new AuthorizeController(userManager.Object, signInManager.Object, jwtSettings);
var tokenResult = await loginController.AuthorizeJwt(LoginData.Authorize);
Assert.IsType <BadRequestObjectResult>(tokenResult.Result);
}
public async Task Authorize_No_Code()
{
var authenticationService = new Mock <IAuthenticationService>();
var botService = new Mock <IBotService>();
var vstsService = new Mock <IVstsService>();
var target = new AuthorizeController(botService.Object, authenticationService.Object, vstsService.Object);
var result = await target.Index(null, null, null) as ViewResult;
Assert.IsNotNull(result);
Assert.IsNotNull(result.ViewData.ModelState.First(pair => pair.Value.Errors.Any()));
}
public async Task Authorize_No_State()
{
var applicationRegistry = new Mock <IVstsApplicationRegistry>();
var botService = new Mock <IBotService>();
var vstsService = new Mock <IVstsService>();
var target = new AuthorizeController(botService.Object, applicationRegistry.Object, vstsService.Object);
var result = await target.Index("123567890", null, null) as ViewResult;
Assert.IsNotNull(result);
Assert.IsNotNull(result.ViewData.ModelState.First(pair => pair.Value.Errors.Any()));
}
public async Task Authorize_No_State()
{
var authenticationServiceMock = new Mock <IAuthenticationService>();
var botDataFactoryMock = new Mock <IBotDataFactory>();
var vstsServiceMock = new Mock <IVstsService>();
var target = new AuthorizeController("appId", new Uri("http://authorize.url"), authenticationServiceMock.Object, botDataFactoryMock.Object, vstsServiceMock.Object);
var result = await target.Index("123567890", null, null) as ViewResult;
Assert.IsNotNull(result);
Assert.IsNotNull(result.ViewData.ModelState.First(pair => pair.Value.Errors.Any()));
}
public async Task Authorize_A_Valid_LogOn()
{
var authenticationService = new Mock <IAuthenticationService>();
var botService = new Mock <IBotService>();
var vstsService = new Mock <IVstsService>();
var token = new OAuthToken();
var profile = new Profile();
var accounts = new List <Account> {
new Account(Guid.NewGuid())
{
AccountName = "Account1"
}
};
var botData = new BotData();
var target = new AuthorizeController(
botService.Object,
authenticationService.Object,
vstsService.Object);
const string code = "1234567890";
const string pin = "12345";
const string state = "channel1;user1";
botData.SetProperty("Pin", pin);
authenticationService
.Setup(a => a.GetToken(code))
.ReturnsAsync(() => token);
vstsService
.Setup(p => p.GetProfile(token))
.ReturnsAsync(profile);
vstsService
.Setup(p => p.GetAccounts(token, It.IsAny <Guid>()))
.ReturnsAsync(accounts);
botService
.Setup(b => b.GetUserData("channel1", "user1"))
.ReturnsAsync(botData);
botService
.Setup(b => b.SetUserData("channel1", "user1", botData))
.Returns(Task.CompletedTask);
var result = await target.Index(code, string.Empty, state) as ViewResult;
var vstsProfile = botData.GetProperty <VstsProfile>("NotValidatedByPinProfile");
result.Should().NotBeNull();
vstsProfile.Should().NotBeNull();
((Authorize)result.Model).Pin.Should().Be(pin);
}
public ServerResponseInformation TestHandleMethod(ClientCommandInformation clientCommand)
{
AuthorizeController authorizeController = (AuthorizeController)_serviceProvider
.GetService(typeof(AuthorizeController));
var resAuthorize = authorizeController.Authorize(clientCommand.ClientLogin);
if (resAuthorize != null)
{
return(resAuthorize);
}
TestController testController = (TestController)_serviceProvider
.GetService(typeof(TestController));
return(testController.RecieveTest(clientCommand));
}
public async Task TEST_AUTHORIZE(string accountName, string password)
{
var mockUser = new ApplicationUser {
AccountName = accountName, Password = password
};
Mock <IAbpAuthorizationService> mockAuthorizationService = new Mock <IAbpAuthorizationService>();
mockAuthorizationService.Setup(item => item.AuthorizationUser(mockUser)).ReturnsAsync(new RESTResult {
Code = RESTStatus.Success
});
var authorizeControoler = new AuthorizeController(mockAuthorizationService.Object);
var result = await authorizeControoler.AuthorizeUser(mockUser);
Assert.IsType <OkObjectResult>(result);
}
private static AuthorizeController CreateDependenciesForLogin(bool isCorrectPassword)
{
var authorizatorMock = new Mock <IAuthorizator>();
authorizatorMock
.Setup(a => a.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(new ApplicationUser());
authorizatorMock
.Setup(a => a.CheckPasswordSignInAsync(
It.IsAny <ApplicationUser>(),
It.IsAny <string>()))
.ReturnsAsync(isCorrectPassword);
var controller = new AuthorizeController(new Mock <IReCaptcha>().Object, authorizatorMock.Object);
return(controller);
}
public async Task Login_GenerateToken()
{
var userManager = GetUserManager();
var signInManager = GetSignInManager(SignInSuccess);
var jwtSettings = JwtSettings;
var loginController = new AuthorizeController(userManager.Object, signInManager.Object, jwtSettings);
var tokenResult = await loginController.AuthorizeJwt(LoginData.Authorize);
var handler = new JwtSecurityTokenHandler();
var tokenDecode = handler.ReadToken(tokenResult.Value) as JwtSecurityToken;
var claims = tokenDecode?.Claims.ToList();
var claimRole = claims?.First(claim => claim.Type == ClaimTypes.Role && claim.Value == LoginData.Roles.First());
Assert.True(!String.IsNullOrWhiteSpace(tokenResult.Value));
Assert.NotNull(claimRole);
}
public ServerResponseInformation GetComputerComponent
(ClientCommandInformation clientCommand)
{
AuthorizeController authorizeController = (AuthorizeController)_serviceProvider
.GetService(typeof(AuthorizeController));
var resAuthorize = authorizeController.Authorize(clientCommand.ClientLogin);
if (resAuthorize != null)
{
return(resAuthorize);
}
ComputerHardwareInformationDTO chInformation = JsonConvert
.DeserializeObject <ComputerHardwareInformationDTO>(clientCommand.SerializedData);
ComputerController computerController = (ComputerController)_serviceProvider
.GetService(typeof(ComputerController));
return(computerController.RecieveComputerHardwareInformation(chInformation, clientCommand.ClientLogin));
}
public ServerResponseInformation GetProcessInformationByName
(ClientCommandInformation clientCommand)
{
AuthorizeController authorizeController = (AuthorizeController)_serviceProvider
.GetService(typeof(AuthorizeController));
var resAuthorize = authorizeController.Authorize(clientCommand.ClientLogin);
if (resAuthorize != null)
{
return(resAuthorize);
}
ProcessInformationDTO processInformationDTO = JsonConvert
.DeserializeObject <ProcessInformationDTO>(clientCommand.SerializedData);
ProcessesController processesController = (ProcessesController)_serviceProvider
.GetService(typeof(ProcessesController));
return(processesController.RecieveProcessInformation(processInformationDTO, clientCommand.ClientLogin));
}
public ServerResponseInformation GetTopMemoryUsageProcesses
(ClientCommandInformation clientCommand)
{
AuthorizeController authorizeController = (AuthorizeController)_serviceProvider
.GetService(typeof(AuthorizeController));
var resAuthorize = authorizeController.Authorize(clientCommand.ClientLogin);
if (resAuthorize != null)
{
return(resAuthorize);
}
IEnumerable <ProcessDTO> processes = JsonConvert
.DeserializeObject <IEnumerable <ProcessDTO> >(clientCommand.SerializedData);
ProcessesController processesController = (ProcessesController)_serviceProvider
.GetService(typeof(ProcessesController));
return(processesController.RecieveProcesses(processes, clientCommand.ClientLogin));
}
private void InitializeController()
{
this.mockAppConfig = new Mock <AppConfig> {
DefaultValue = DefaultValue.Mock
};
this.logger = new Mock <ILogger <UserTenantContainer> >();
this.mockUserTenantContainer = new Mock <UserTenantContainer>(
this.logger.Object,
new AppConfig()
{
DeviceTelemetryService = new DeviceTelemetryServiceConfig
{
Messages = new MessagesConfig
{
TelemetryStorageType = "cosmosdb",
},
},
},
new Mock <IGrafanaClient>().Object,
new Mock <IKeyVaultClient>().Object);
this.mockUserSettingsContainer = new Mock <IUserContainer <UserSettingsModel, UserSettingsInput> >();
this.mockJwtHelper = new Mock <IJwtHelpers> {
DefaultValue = DefaultValue.Mock
};
this.mockAuthContext = new Mock <IAuthenticationContext> {
DefaultValue = DefaultValue.Mock
};
this.mockHttpContext = new Mock <HttpContext> {
DefaultValue = DefaultValue.Mock
};
this.mockOpenIdProviderConfiguration = new Mock <IOpenIdProviderConfiguration> {
DefaultValue = DefaultValue.Mock
};
this.controller = new AuthorizeController(this.mockAppConfig.Object, this.mockUserTenantContainer.Object, this.mockUserSettingsContainer.Object as UserSettingsContainer, this.mockJwtHelper.Object, this.mockOpenIdProviderConfiguration.Object, this.mockAuthContext.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = this.mockHttpContext.Object,
},
};
}
private static AuthorizeController CreateDependenciesForRegister(bool isSuccess, string error)
{
var authorizatorMock = new Mock <IAuthorizator>();
authorizatorMock
.Setup(a => a.CreateAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.ReturnsAsync((isSuccess, error));
authorizatorMock
.Setup(a => a.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(new ApplicationUser());
authorizatorMock
.Setup(a => a.CheckPasswordSignInAsync(
It.IsAny <ApplicationUser>(),
It.IsAny <string>()))
.ReturnsAsync(true);
var reCaptcha = new Mock <IReCaptcha>();
reCaptcha.Setup(rc => rc.Verify(It.IsAny <string>())).ReturnsAsync(true);
var controller = new AuthorizeController(reCaptcha.Object, authorizatorMock.Object);
return(controller);
}
public async Task Authorize_A_Valid_LogOn()
{
var authenticationServiceMock = new Mock <IAuthenticationService>();
var botDataFactoryMock = new Mock <IBotDataFactory>();
var botData = new Mock <IBotData>();
var botDataBag = new Mock <IBotDataBag>();
var vstsServiceMock = new Mock <IVstsService>();
var token = new OAuthToken();
var profile = new Microsoft.VisualStudio.Services.Profile.Profile {
DisplayName = "UniqueName"
};
var accounts = new List <Account> {
new Account(Guid.NewGuid())
{
AccountName = "Account1"
}
};
var target = new AuthorizeController("appId", new Uri("http://authorize.url"), authenticationServiceMock.Object, botDataFactoryMock.Object, vstsServiceMock.Object);
const string code = "1234567890";
const string state = "channel1;user1";
var data = new UserData {
Pin = "12345"
};
authenticationServiceMock
.Setup(a => a.GetToken("appId", new Uri("http://authorize.url"), code))
.ReturnsAsync(() => token);
vstsServiceMock
.Setup(p => p.GetProfile(token))
.ReturnsAsync(profile);
vstsServiceMock
.Setup(p => p.GetAccounts(token, It.IsAny <Guid>()))
.ReturnsAsync(accounts);
botDataFactoryMock
.Setup(b => b.Create(It.Is <Address>(a =>
a.ChannelId.Equals("channel1", StringComparison.Ordinal) &&
a.UserId.Equals("user1", StringComparison.Ordinal))))
.Returns(botData.Object);
botData
.Setup(bd => bd.UserData)
.Returns(botDataBag.Object);
botDataBag
.Setup(bd => bd.TryGetValue("userData", out data))
.Returns(true);
var result = await target.Index(code, string.Empty, state) as ViewResult;
botDataBag
.Verify(bd => bd.SetValue("userData", data));
result.Should().NotBeNull();
((Authorize)result.Model).Pin.Should().Be(data.Pin);
data.Profiles.Should().Contain(p => p.Id.Equals(profile.Id));
}
