public KeyVaultConfigurationSettings(string authUrl, string vaultUrl, string identity, string credential, Authentication.AuthenticationType credentialType, string secretPrefix)
{
AuthURL = authUrl;
VaultURL = vaultUrl;
ConnectingAccountIdentity = identity;
ConnectingAccountCredential = credential;
CredentialType = credentialType;
SecretPrefix = secretPrefix;
}
public void Credential_ExpiryDateIsValid_ReturnsTrue(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
var result = connectionService.IsValidCredential(out var message);
Assert.True(result, "Expected value: true; the credential expiry should be evaluated as 'valid' (not expired)");
}
public void SignInCommand_CredentialIsValid_ReturnsTrue(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
if (type == Authentication.AuthenticationType.Studio)
{
connectionService.IsValidStudioCredential(out Arg.Any <string>()).Returns(x =>
{
x[0] = "Credential is not valid!";
return(false);
});
var languageCloudIdentityApiModel = new LanguageCloudIdentityApiModel
{
AccessToken = credential.Token,
Email = credential.Name
};
connectionService.StudioSignIn()
.Returns(new Tuple <LanguageCloudIdentityApiModel, string>(languageCloudIdentityApiModel, string.Empty));
}
else
{
var authorizationResponse = new AuthorizationResponse
{
AccessToken = credential.Token
};
connectionService.SignIn(Arg.Any <string>(), Arg.Any <string>())
.Returns(Task.FromResult(new Tuple <AuthorizationResponse, string>(authorizationResponse, string.Empty)));
}
var userDetails = new UserDetails
{
AccountId = 0123,
UserId = type != Authentication.AuthenticationType.Client ? "abc123" : null,
ClientId = type == Authentication.AuthenticationType.Client ? "abc123" : null,
};
connectionService.GetUserDetails(Arg.Any <string>(), Arg.Any <string>())
.Returns(Task.FromResult(new Tuple <UserDetails, string>(userDetails, string.Empty)));
var model = Substitute.For <CredentialsViewModel>(null, connectionService);
Assert.False(model.IsSignedIn, "Expected: 'False' Found: 'True'");
model.SignInCommand.Execute(null);
Assert.True(model.IsSignedIn, "Expected: 'True' Found: 'False'");
}
public ICredential GetDefaultCredential(Authentication.AuthenticationType type)
{
var credential = new Credential
{
Type = type,
ValidTo = DateTime.UtcNow.AddHours(1),
Token = "abc123",
Name = "Name",
Password = "******",
AccountId = "0123456789"
};
return(credential);
}
public void Credential_PasswordIsEmpty_ReturnsFalse(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
credential.Password = string.Empty;
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
var result = connectionService.IsValidCredential(out var message);
Assert.False(result, "Expected value: false; the credential Password should be evaluated as 'not valid' (empty)");
}
public void Credential_ExpiryDateIsValid_ReturnsFalse(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
credential.ValidTo = DateTime.UtcNow.Subtract(new TimeSpan(0, 1, 0, 0, 0));
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
var result = connectionService.IsValidCredential(out var message);
Assert.False(result, "Expected value: false; the credential expiry date should be evaluated as 'not valid' (expired)");
}
public void Connect_CredentialIsInvalidAndAttemptConnection_ReturnsFalse(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
credential.ValidTo = DateTime.UtcNow.Subtract(new TimeSpan(0, 1, 0, 0, 0));
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
if (type == Authentication.AuthenticationType.Studio)
{
connectionService.IsValidStudioCredential(out Arg.Any <string>()).Returns(x =>
{
x[0] = "Credential has expired";
return(false);
});
var languageCloudIdentityApiModel = new LanguageCloudIdentityApiModel
{
AccessToken = string.Empty,
Email = string.Empty
};
connectionService.StudioSignIn()
.Returns((languageCloudIdentityApiModel, "Invalid Credentials!"));
}
else
{
var authorizationResponse = new AuthorizationResponse
{
AccessToken = string.Empty
};
connectionService.SignIn(Arg.Any <string>(), Arg.Any <string>())
.Returns(Task.FromResult((authorizationResponse, "Invalid Credentials!")));
}
var userDetails = new UserDetails
{
AccountId = 0123,
UserId = type != Authentication.AuthenticationType.Client ? "abc123" : null,
ClientId = type == Authentication.AuthenticationType.Client ? "abc123" : null,
};
connectionService.GetUserDetails(Arg.Any <string>())
.Returns(Task.FromResult((userDetails, string.Empty)));
var result = connectionService.Connect(credential);
Assert.False(result.Item1, "Expected value: false");
}
public void Constructor_InitializesPropertiesCorrectly_ReturnsTrue(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
if (type == Authentication.AuthenticationType.Studio)
{
connectionService.IsValidStudioCredential(out Arg.Any <string>()).Returns(x =>
{
x[0] = string.Empty;
return(true);
});
}
var model = Substitute.For <CredentialsViewModel>(null, connectionService);
Assert.True(model.SelectedAuthentication.Type == credential.Type, "Expected: '" + credential.Type + "' Found: '" + model.SelectedAuthentication.Type + "'");
switch (type)
{
case Authentication.AuthenticationType.Studio:
Assert.True(model.StudioSignedInAs == credential.Name, "Expected: '" + credential.Name + "' Found: '" + model.StudioSignedInAs + "'");
break;
case Authentication.AuthenticationType.User:
Assert.True(model.UserName == credential.Name, "Expected: '" + credential.Name + "' Found: '" + model.UserName + "'");
Assert.True(model.UserPassword == credential.Password, "Expected: '" + credential.Password + "' Found: '" + model.UserPassword + "'");
break;
case Authentication.AuthenticationType.Client:
Assert.True(model.ClientId == credential.Name, "Expected: '" + credential.Name + "' Found: '" + model.ClientId + "'");
Assert.True(model.ClientSecret == credential.Password, "Expected: '" + credential.Password + "' Found: '" + model.ClientSecret + "'");
break;
}
}
public void Connect_CredentialIsValid_ReturnsTrue(Authentication.AuthenticationType type)
{
var credential = _common.GetDefaultCredential(type);
var connectionService = Substitute.For <Service.ConnectionService>(null, null, null);
connectionService.Credential.Returns(credential);
if (type == Authentication.AuthenticationType.Studio)
{
connectionService.IsValidStudioCredential(out Arg.Any <string>()).Returns(x =>
{
x[0] = string.Empty;
return(true);
});
var languageCloudIdentityApiModel = new LanguageCloudIdentityApiModel
{
AccessToken = credential.Token,
Email = credential.Name
};
connectionService.StudioSignIn().Returns((languageCloudIdentityApiModel, string.Empty));
var userDetails = new UserDetails
{
AccountId = 0123,
UserId = "abc123",
ClientId = null
};
connectionService.GetUserDetails(Arg.Any <string>()).Returns(
Task.FromResult((userDetails, string.Empty)));
}
var result = connectionService.Connect(credential);
Assert.True(result.Item1, "Expected value: true");
}
