public override void Initialize(BaseController _tokenController)
{
m_tokenController = (TokenController)_tokenController;
m_tokenController.GetModel().OnTokenMoved += OnTokenMoved;
m_tokenController.GetModel().OnTokenTeleported += OnTokenTeleported;
m_boardController = GameObject.FindObjectOfType<BoardController>();
base.Initialize(_tokenController);
}
public void Should_return_ok_token_response()
{
var result = TokenController.GetSelfTestToken(participantId);
var typedResult = (OkObjectResult)result;
typedResult.Should().NotBeNull();
var tokenResponse = (TokenResponse)typedResult.Value;
tokenResponse.Token.Should().Be(token);
tokenResponse.ExpiresOn.Length.Should().BeGreaterOrEqualTo(15);
tokenResponse.ExpiresOn.Length.Should().BeLessOrEqualTo(17);
hashGenerator.Verify(h => h.GenerateSelfTestTokenHash(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public App()
{
Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense("Mjc5NDMzQDMxMzgyZTMxMmUzMER2bTdGc1JRSWNqTHdHRjJCcDYraEFiMSs5WnNoUStHM2I4Q1hSdlBOYTg9");
InitializeComponent();
var tokenController = new TokenController();
if (tokenController.Token_Expired())
{
MainPage = new NavigationPage(new Login_View());
}
else
{
MainPage = new NavigationPage(new MainPage());
}
}
public async Task GetNotFound()
{
var authManager = new Mock <IAuthManager>();
authManager.Setup(c => c.VerifyAccessToken(It.IsAny <string>()))
.Returns <string>(r => Task.FromResult(default(Models.TransferObjects.AuthToken)));
var sut = new TokenController(authManager.Object);
var result = await sut.Get("testtoken");
var resultObject = (GenericWrapper <bool>)result.Value;
Assert.IsFalse(resultObject.Value);
}
public async Task <int> TokenBalance(string username)
{
string userAddress = ActivatePlayer(username).ethAddress; // UserInfo<string>(username, "ethAddress");
if (userAddress != null)
{
float result = await TokenController.GetBalance(userAddress);
return((int)result);
}
else
{
return(0);
}
}
public void GetJwtTokenWithInCorrectData(string username, string password)
{
Assert.That(() =>
{
var controller = new TokenController();
controller.Post(new User(Guid.NewGuid(), username)
{
PasswordHash = password
});
}, Throws.Exception
.TypeOf <HttpResponseException>()
//.With.Property("statusCode")
//.EqualTo(HttpStatusCode.Unauthorized)
);
}
protected override Task ArrangeAsync()
{
_suppliedClient = new ApiClient
{
ApiClientId = 1
};
_apiClientAuthenticator = Stub <IApiClientAuthenticator>();
var ApplicationEducationOrganizations = new List <int>()
{
997, 998, 999
};
// Scope the request to the first associated EdOrg
_requestedScope = ApplicationEducationOrganizations
.First()
.ToString();
_suppliedAccessToken = Guid.NewGuid();
_accessTokenClientRepo = Stub <IAccessTokenClientRepo>();
A.CallTo(() => _accessTokenClientRepo.AddClientAccessTokenAsync(A <int> ._, A <string> ._))
.Returns(
new ClientAccessToken(new TimeSpan(0, 10, 0))
{
ApiClient = _suppliedClient,
Id = _suppliedAccessToken
});
A.CallTo(() => _apiClientAuthenticator.TryAuthenticateAsync(A <string> ._, A <string> ._))
.Returns(
Task.FromResult(
new ApiClientAuthenticator.AuthenticationResult
{
IsAuthenticated = true,
ApiClientIdentity = new ApiClientIdentity {
Key = "clientId",
EducationOrganizationIds = ApplicationEducationOrganizations,
ApiClientId = _suppliedClient.ApiClientId,
}
}));
_controller = ControllerHelper.CreateTokenController(_apiClientAuthenticator, _accessTokenClientRepo);
return(Task.CompletedTask);
}
public async Task Auth_Should_Return_UnauthorizedResult_If_TokenRequestViewModel_GrantType_Is_Not_password_Or_refresh_token()
{
this.tokenServiceMock = new Mock <ITokenService>();
this.configurationMock = new Mock <IConfiguration>();
this.tokenController = new TokenController(this.tokenServiceMock.Object, this.configurationMock.Object);
var model = this.CreateTokenRequestModelWithPasswordGrantType();
model.grant_type = string.Empty;
IActionResult result = await this.tokenController.Auth(model);
this.Annihilate();
var unauthorizedResult = result.Should().BeOfType <UnauthorizedResult>();
}
protected override Task ArrangeAsync()
{
_suppliedClient = new ApiClient {
ApiClientId = 1
};
_suppliedAccessToken = Guid.NewGuid();
_accessTokenClientRepo = Stub <IAccessTokenClientRepo>();
_apiClientAuthenticator = Stub <IApiClientAuthenticator>();
_controller = ControllerHelper.CreateTokenController(_apiClientAuthenticator, _accessTokenClientRepo);
return(Task.CompletedTask);
}
private void FrmInicio_Load(object sender, EventArgs e)
{
TokenController tokenController = new TokenController();
//tokenController.IniciarDicionarioTokens();
tokenController.IniciarDicionarioTokens();
//tokenController.IniciarCatalogoParsing();
LineNumberTextBox.Font = TxtEditorTexto.Font;
TxtEditorTexto.Select();
AddLineNumbers();
TxtSaida.Text = "Saída >>";
}
public void Get_With_Success_Returns_Token()
{
//Arrange
var token = "abc123";
var userId = Guid.NewGuid();
var mockHttpAccessorService = HttpContextAccessorMocks.MockReturningUserId(userId);
var mockTokenService = TokenServiceMocks.MockReturningGenerateToken(token);
//Act
var tokenController = new TokenController(mockHttpAccessorService, null, mockTokenService);
var result = (SuccessResult)tokenController.Get();
var response = (SuccessResponse)result.Value;
//Assert
Assert.Equal(response.Data, token);
}
public async void GetTokenValidUser_Test()
{
// Arrange
var tokenController = new TokenController(_config, _personRepository.Object, _emailHelper.Object, _tokenClass.Object);
// Act
var result = await tokenController.GetRandomToken(_newPerson.Name, _newPerson.HashedPassword);
var okResult = result as OkObjectResult;
var token = okResult.Value as string;
// Assert
Assert.True(okResult != null);
Assert.True(token != null);
Assert.Equal(200, okResult.StatusCode);
}
public void IsTokenNull_When_InvalidUserCredentialsAreUsed()
{
//Arrange
Mock <IConfiguration> config = new Mock <IConfiguration>();
//Act
var TokenObj = new TokenController(config.Object);
var response = TokenObj.Login(new Authenticate()
{
Name = "wronginput", Password = "******"
});
var result = response as UnauthorizedResult;
//Assert
Assert.AreEqual(401, result.StatusCode);
}
public async void RequestToken_ReturnsSuccess()
{
_userService.Setup(s => s.ValidateUserPassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
_userService.Setup(s => s.GetUser(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((string email, CancellationToken cancellationToken) => new User
{
Id = 1,
Email = email,
UserName = email,
IsActive = true
});
_userService.Setup(s => s.GetUserRole(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(UserRole.Administrator);
_projectService.Setup(s => s.GetProjectsByUser(1, It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <(Project, ProjectMemberRole)>
{
(new Project
{
Id = 1,
Name = "Project01"
}, new ProjectMemberRole
{
Id = 1,
Name = MemberRole.Owner
})
});
_configuration.SetupGet(x => x["Security:Tokens:Key"]).Returns("key12345678910abcdefghijklmnopqrstuvwxyz");
_configuration.SetupGet(x => x["Security:Tokens:Issuer"]).Returns("issuer");
_configuration.SetupGet(x => x["Security:Tokens:Audience"]).Returns("audience");
var controller = new TokenController(_userService.Object, _projectService.Object, _catapultEngineService.Object, _configuration.Object, _logger.Object);
var dto = new RequestTokenDto
{
Email = "*****@*****.**"
};
var result = await controller.RequestToken(dto);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <string>(okResult.Value);
Assert.NotEmpty(returnValue);
}
public async Task PostChatToken_WithInvalidSettings_ThrowsException()
{
// ARRANGE
_chatSettingsMock.SetupGet(x => x.CurrentValue).Returns(new TwilioChatSettings {
ApiKey = string.Empty, ApiSecret = string.Empty, ServiceSid = string.Empty
});
_twilioSettingsMock.SetupGet(x => x.CurrentValue).Returns(new TwilioAccountSettings {
AccountSid = string.Empty, AuthToken = string.Empty
});
_controller = new TokenController(_loggerMock.Object, _twilioSettingsMock.Object, _chatSettingsMock.Object, _callSettingsMock.Object);
// ACT
// ASSERT
await Assert.ThrowsAsync <ApplicationException>(async() => await _controller.PostChatToken());
}
public void Get_Token_Should_Return_ForbidRequest()
{
// Arange
_mockService.Setup(svc => svc.AuthenticateAsync(It.IsAny <LoginCredentials>())).ReturnsAsync("FakeTokenString");
TokenController controller = new TokenController(_mockService.Object);
// Act
var response = controller.Post(new LoginCredentials {
UserName = "", Password = ""
}).Result;
// Assert
var result = response.Should().BeOfType <ForbidResult>().Subject.AuthenticationSchemes.SingleOrDefault();
var body = result.Should().BeAssignableTo <string>().Subject;
body.Should().Be("Login Failed");
}
public void Get_Token_Should_Return_Token()
{
// Arange
_mockService.Setup(svc => svc.AuthenticateAsync(It.IsAny <LoginCredentials>())).ReturnsAsync("FakeTokenString");
TokenController controller = new TokenController(_mockService.Object);
// Act
var response = controller.Post(new LoginCredentials {
UserName = "******", Password = "******"
}).Result;
// Assert
var result = response.Should().BeOfType <OkObjectResult>().Subject;
var body = result.Value.Should().BeAssignableTo <string>().Subject;
body.Should().Be("FakeTokenString");
}
public TokenTests()
{
AppSettings appSettings = new AppSettings()
{
ConnectionString = "Server=127.0.0.1;Database=Cylance; Trusted_Connection=True;"
};
var provider = new ServiceCollection()
.AddMemoryCache()
.BuildServiceProvider();
//And now?
var cache = provider.GetService <IMemoryCache>();
IOptions <AppSettings> options = Options.Create(appSettings);
controller = new TokenController(options, cache);
}
public async Task DeleteThrowsError()
{
const bool response = true;
var authManager = new Mock <IAuthManager>();
authManager.Setup(c => c.DeleteAccessToken(It.IsAny <string>()))
.Returns <string>(r => Task.FromResult(response));
var sut = new TokenController(authManager.Object);
var result = await sut.Delete();
var resultObject = (GenericWrapper <bool>)result.Value;
Assert.AreEqual(response, resultObject.Value);
}
protected override Task ArrangeAsync()
{
_accessTokenClientRepo = Stub <IAccessTokenClientRepo>();
_apiClientAuthenticator = Stub <IApiClientAuthenticator>();
A.CallTo(() => _apiClientAuthenticator.TryAuthenticateAsync(A <string> ._, A <string> ._))
.Returns(
Task.FromResult(
new ApiClientAuthenticator.AuthenticationResult {
IsAuthenticated = false
}));
_controller = ControllerHelper.CreateTokenController(_apiClientAuthenticator, _accessTokenClientRepo);
return(Task.CompletedTask);
}
public async Task When_Login_Then_Return_BearerTokenAsync()
{
// Arrange: 初始化的過程
var FakeModel = new LoginViewModel()
{
Account = "*****@*****.**",
Password = "******"
};
_jwtServiceMock.Setup(x => x.GenerateToken(It.IsAny<string>(), It.IsAny<int>())).Returns("BearerToken");
_userServiceMock.Setup(x => x.LoginVerify(It.IsAny<LoginViewModel>())).Returns(Task.FromResult(true));
TokenController controller = new TokenController(_jwtServiceMock.Object, _contextMock.Object, _userServiceMock.Object);
// Act: 執行測試的目標，並取得實際結果
var actual = await controller.Login(FakeModel);
// Assert: 驗證結果
Assert.IsInstanceOf(typeof(string), actual.Value);
}
// Use this for initialization
void Start()
{
//Set patrol path
start = new Vector3(transform.position.x - destDist, transform.position.y);
des = new Vector3(transform.position.x + destDist, transform.position.y);
//Grab AI References
aiRef = GetComponent <AI>();
aiControlRef = GetComponent <AI_Controller>();
customPartRef = GetComponentInChildren <CustomParticles>();
rbRef = GetComponent <Rigidbody2D>();
aiWallRayRef = GetComponentInChildren <AI_WallRay>();
playerChar = GameObject.FindGameObjectWithTag("Player").transform;
tokenControl = GameObject.FindGameObjectWithTag("PlayerReferences").GetComponent <TokenController>();
ApplyAIReferences();
}
private void GetDataFromJsonFiles()
{
IsBusy = true;
var _tokenController = new TokenController();
var token = _tokenController.DecodeToken();
if (token.Item1)
{
Token = token.Item2;
}
else
{
CrossSecureStorage.Current.SetValue("LogguedIn", "False");
CrossSecureStorage.Current.DeleteKey("acces_token");
Application.Current.MainPage = new Login_View();
return;
}
string JsonFile = "wilayas.json";
var assembly = IntrospectionExtensions.GetTypeInfo(typeof(ContactPage_ViewModel)).Assembly;
Stream stream = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.{JsonFile}");
using (var reader = new StreamReader(stream))
{
var json = reader.ReadToEnd();
Wilaya = JsonConvert.DeserializeObject <List <Wilaya_Model> >(json);
}
JsonFile = "communes.json";
assembly = IntrospectionExtensions.GetTypeInfo(typeof(ContactPage_ViewModel)).Assembly;
stream = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.{JsonFile}");
using (var reader = new StreamReader(stream))
{
var json = reader.ReadToEnd();
All_Commune = JsonConvert.DeserializeObject <List <Commune> >(json);
}
JsonFile = "speciality.json";
assembly = IntrospectionExtensions.GetTypeInfo(typeof(ContactPage_ViewModel)).Assembly;
stream = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.{JsonFile}");
using (var reader = new StreamReader(stream))
{
var json = reader.ReadToEnd();
Speciality = JsonConvert.DeserializeObject <List <string> >(json);
}
IsBusy = false;
}
public async void RequestToken_ReturnsUserPasswordInvalid()
{
_userService.Setup(s => s.ValidateUserPassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
var controller = new TokenController(_userService.Object, _projectService.Object, _catapultEngineService.Object, _configuration.Object, _logger.Object);
var dto = new RequestTokenDto
{
Email = "*****@*****.**"
};
var result = await controller.RequestToken(dto);
var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal("Username or password is invalid", badRequestResult.Value);
}
public async void GetTokenResetPassword_Test()
{
// Arrange
var tokenController = new TokenController(_config, _personRepository.Object, _emailHelper.Object, _tokenClass.Object);
_newPerson.ChangePassword = "******";
// Act
var result = await tokenController.GetRandomToken(_newPerson.Name, _newPerson.HashedPassword);
var okResult = result as OkObjectResult;
var returnedMessage = okResult.Value as string;
// Assert
Assert.True(okResult != null);
Assert.True(returnedMessage == "User must change password");
Assert.Equal(200, okResult.StatusCode);
}
private void Initialize()
{
var _tokenController = new TokenController();
var Result = _tokenController.DecodeToken();
if (Result.Item1)
{
Token = Result.Item2;
if (Result.Item2.permissions.Contains("Tournée Libre"))
{
IsFreeMission = true;
}
}
else
{
return;
}
}
public void Setup()
{
_config = new Mock <IConfiguration>();
_config.Setup(c => c["Jwt:Key"]).Returns("ThisismySecretKey");
_repository = new AuthUserRepository(_config.Object);
_service = new AuthUserService(_repository);
_controller = new TokenController(_service);
user1 = new Users()
{
Email = "admin",
Password = "******"
};
user2 = new Users()
{
Email = "Admi",
Password = "******"
};
}
public async Task Auth_Should_Return_UnauthorizedResult_If_GrantType_Is_refresh_token_And_TokenService_Throws_UserTokenNotFoundException()
{
this.tokenServiceMock = new Mock <ITokenService>();
this.tokenServiceMock.Setup(m => m.ReplaceUserRefreshToken(It.IsAny <string>(), It.IsAny <string>()))
.Throws <UserTokenNotFoundException>();
this.configurationMock = new Mock <IConfiguration>();
this.tokenController = new TokenController(this.tokenServiceMock.Object, this.configurationMock.Object);
var model = this.CreateTokenRequestModelWithPasswordGrantType();
model.grant_type = "refresh_token";
IActionResult result = await this.tokenController.Auth(model);
this.Annihilate();
var unauthorizedResult = result.Should().BeOfType <UnauthorizedResult>();
}
public void Login()
{
Mock <IConfiguration> config = new Mock <IConfiguration>();
config.Setup(p => p["Jwt:Key"]).Returns("ThisismySecretKey");
TokenController controller = new TokenController(config.Object);
var auth = controller.Login(new Users {
Email = "admin", Password = "******"
}) as OkObjectResult;
Assert.AreEqual(200, auth.StatusCode);
Users user = new Users {
Email = "admin", Password = "******"
};
var result = s.Login(user);
Assert.IsNotNull(result);
}
public void TestGetTokenInvalido()
{
//Arrange
User user = new User()
{
Contrasena = "prueba3456", Usuario = "prueba"
};
TokenController controller = new TokenController();
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
//Act
var response = controller.Get(user);
//Assert
Assert.AreEqual(System.Net.HttpStatusCode.Unauthorized, response.StatusCode);
}
public void CreateToken_WhenCalledNombreNull_ReturnBadRequest()
{
//Arrange
_controller = new TokenController(_configuration, _usersInfoRepository);
var usuario = new everisapi.API.Models.UsersSinProyectosDto
{
Nombre = null
, Password = "******"
, NombreCompleto = "Francisco Javier Moreno Vicente"
};
//Act
var okResult = _controller.CreateToken(UserAuth: usuario);
//Assert
Assert.IsType <UnauthorizedResult>(okResult);
}
public Response<Token> getToken(string email, string password)
{
IncomingWebRequestContext requestContext = WebOperationContext.Current.IncomingRequest;
Dictionary<string, string> data = new Dictionary<string, string>();
string authString = requestContext.Headers[HttpRequestHeader.Authorization];
data.Add("email", email);
data.Add("password", password);
Request request = makeRequest(requestContext, trimData(data), authString);
TokenController controller = new TokenController();
return controller.Call(request);
}
public Response<Token> renewToken()
{
IncomingWebRequestContext requestContext = WebOperationContext.Current.IncomingRequest;
Dictionary<string, string> data = new Dictionary<string, string>();
string authString = requestContext.Headers[HttpRequestHeader.Authorization];
Request request = makeRequest(requestContext, trimData(data), authString);
TokenController controller = new TokenController();
return controller.Call(request);
}
void Awake()
{
controller = this.GetComponentInParent<TokenController> ();
}
private void SetupTokensView()
{
m_pcTokenController = PcTokenView.GetComponent<TokenController>();
m_pcTokenController.Initialize();
PcTokenView.Initialize(m_pcTokenController);
PcTokenView.OnTokenAnimationMovedFinished += OnTokenAnimationMovedFinished;
PcTokenView.OnTokenAnimationTeleportedFinished += OnTokenAnimationTeleportedFinished;
m_playerTokenController = PlayerTokenView.GetComponent<TokenController>();
m_playerTokenController.Initialize();
PlayerTokenView.Initialize(m_playerTokenController);
PlayerTokenView.OnTokenAnimationMovedFinished += OnTokenAnimationMovedFinished;
PlayerTokenView.OnTokenAnimationTeleportedFinished += OnTokenAnimationTeleportedFinished;
m_pcTokenController.GetModel().OnFinishTileReached += OnPcTokenFinishTileReached;
m_playerTokenController.GetModel().OnFinishTileReached += OnPlayerFinishTileReached;
}
