public void Should_Not_Save_When_Duplicate_Name()
{
// arrange
IConnectionRepository connectionRepository = this.GetConnectionRepository();
ConnectionModel connection1 = new ConnectionModel();
connection1.Name = "connection1";
connectionRepository.AddConnection(connection1);
ConnectionModel connection2 = new ConnectionModel();
connection2.Name = "connection1";
connectionRepository.AddConnection(connection2);
// act
bool exceptionThrown = false;
try
{
connectionRepository.Save();
}
catch
{
exceptionThrown = true;
}
// assert
Assert.IsTrue(exceptionThrown);
}
public async Task SwitchAccountConnection(string username, string instance, bool connect,
CancellationToken cancellationToken)
{
var id = new AccountIdentifier(new Username(username), new Instance(instance));
var mastodonAccount = await _mastodonAccountRepository.FindMastodonAccount(id, cancellationToken);
if (mastodonAccount is not null)
{
if (connect)
{
var connection = _makeMastodonConnection.MakeConnection(mastodonAccount.Username.Value, mastodonAccount.Instance.Value,
mastodonAccount.AccessToken.Token);
_connectionRepository.AddConnection(new Connection(id, connection));
}
else
{
_connectionRepository.StopConnection(id);
}
mastodonAccount.IsReadingPostsFromThisAccount = new IsReadingPostsFromThisAccount(connect);
await _mastodonAccountRepository.SaveMastodonAccount(mastodonAccount, cancellationToken);
return;
}
var misskeyAccount = await _misskeyAccountRepository.FindMisskeyAccount(id, cancellationToken);
if (misskeyAccount is not null)
{
if (connect)
{
var connection = _makeMisskeyConnection.MakeConnection(misskeyAccount.Username.Value,
misskeyAccount.Instance.Value, misskeyAccount.AccessToken.Token);
_connectionRepository.AddConnection(new Connection(id, connection));
}
else
{
_connectionRepository.StopConnection(id);
}
misskeyAccount.IsReadingPostsFromThisAccount = new IsReadingPostsFromThisAccount(connect);
await _misskeyAccountRepository.SaveMisskeyAccount(misskeyAccount, cancellationToken);
return;
}
}
public void Should_Allow_Add()
{
// arrange
IConnectionRepository connectionRepository = this.GetConnectionRepository();
// act
connectionRepository.AddConnection(new ConnectionModel());
// assert
Assert.IsTrue(connectionRepository.Count == 1);
}
public void Should_Return_Item_For_Valid_Id()
{
// arrange
IConnectionRepository connectionRepository = this.GetConnectionRepository();
ConnectionModel connection = new ConnectionModel();
connection.ConnectionId = 1;
connectionRepository.AddConnection(connection);
// act
ConnectionModel retrievedConnection = connectionRepository.GetConnection(1);
// assert
Assert.IsTrue(retrievedConnection.ConnectionId == 1);
}
public void Should_Allow_Remoe()
{
// arrange
IConnectionRepository connectionRepository = this.GetConnectionRepository();
ConnectionModel connection = new ConnectionModel();
connection.ConnectionId = 1;
connectionRepository.AddConnection(connection);
// act
connectionRepository.RemoveConnection(connection);
ConnectionModel retrievedConnection = connectionRepository.GetConnection(1);
// assert
Assert.IsNull(retrievedConnection);
}
public Task <string> Connect(ConnectionData connection)
{
var connectionId = _connectionRepository.AddConnection(connection);
return(Task.FromResult(connectionId));
}
public async Task Authorize(InstanceAndAuthenticationCode instanceAndAuthenticationCode,
CancellationToken cancellationToken)
{
var instance = new Instance(instanceAndAuthenticationCode.Instance);
AccessInfo accessInfo;
try
{
var client = await _mastodonClientRepository.FindMastodonClient(instance, cancellationToken);
if (client is null)
{
_showMastodonAuthenticationError.ShowMastodonAuthenticationError();
return;
}
var authorizationInfo = new AuthorizationInfo(instance.Value, client.ClientId.Value,
client.ClientSecret.Value, instanceAndAuthenticationCode.AuthenticationCode);
accessInfo =
await _authorizeMastodonAccountWithCode.AuthorizeMastodonAccountWithCode(authorizationInfo,
cancellationToken);
}
catch
{
_showMastodonAuthenticationError.ShowMastodonAuthenticationError();
return;
}
AccountInfo accountInfo;
try
{
accountInfo = await _getAccountInfo.GetAccountInfo(accessInfo, cancellationToken);
}
catch
{
_showGetMastodonAccountInfoError.ShowGetMastodonAccountInfoError();
return;
}
var username = new Username(accountInfo.Username);
var displayName = new DisplayName(accountInfo.DisplayName);
var accessToken = new MastodonAccessToken(accessInfo.Token);
var iconUrl = new AccountIconUrl(accountInfo.IconUrl);
var account =
await _mastodonAccountRepository.FindMastodonAccount(new AccountIdentifier(username, instance),
cancellationToken);
if (account is null)
{
account = _mastodonAccountRepository.CreateMastodonAccount(username, instance, displayName, accessToken,
iconUrl);
}
else
{
account = account with {
AccessToken = accessToken, IconUrl = iconUrl
};
}
await _mastodonAccountRepository.SaveMastodonAccount(account, cancellationToken);
var connection = _makeMastodonConnection.MakeConnection(account.Username.Value, account.Instance.Value,
account.AccessToken.Token);
_connectionRepository.AddConnection(new Connection(account.AccountIdentifier, connection));
_finishAuthorizeMastodonAccount.FinishAuthorizeMastodonAccount();
}
}
public async Task Login(string host, CancellationToken cancellationToken)
{
string secret;
try
{
secret = await _registerClient.RegisterClient(host, cancellationToken);
}
catch
{
_showRegisterClientError.ShowRegisterClientError();
throw;
}
var(sessionToken, authorizeUrl) =
await _getAuthorizeUrl.GetAuthorizeUri(host, secret, cancellationToken);
_showAuthUrl.ShowAuthUrl(authorizeUrl);
while (true)
{
try
{
await _waitAuthorize.WaitAuthorize(cancellationToken);
break;
}
catch
{
_showAuthorizeError.ShowAuthorizeError();
}
}
var(accessTokenData, user) =
await _getAccessToken.GetAccessToken(host, secret, sessionToken, cancellationToken);
var username = new Username(user.Username);
var instance = new Instance(host);
var displayName = new DisplayName(user.DisplayName);
var identifier = new AccountIdentifier(username, instance);
var accessToken = new MisskeyAccessToken(accessTokenData);
var iconUrl = new AccountIconUrl(user.IconUrl);
var account = await _accountRepository.FindMisskeyAccount(identifier, cancellationToken);
if (account is not null)
{
account = account with {
AccessToken = accessToken, IconUrl = iconUrl
};
}
else
{
account = new MisskeyAccount(username, instance, displayName, accessToken, iconUrl,
new IsReadingPostsFromThisAccount(true));
}
await _accountRepository.SaveMisskeyAccount(account, cancellationToken);
var connection = _makeMisskeyConnection.MakeConnection(account.Username.Value, account.Instance.Value,
account.AccessToken.Token);
_connectionRepository.AddConnection(new Connection(account.AccountIdentifier, connection));
}
