public void ReplaceUserClaim_WithUserNull_ShouldThrowNotFoundRpcException()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
var request = new ReplaceUserClaimRequest
{
UserId = new UserId(),
Claim = new UserClaimDto
{
Type = CustomClaimTypes.StripeCustomer,
Value = "customerId"
}
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act Assert
var func = new Func <Task>(async() => await client.ReplaceUserClaimAsync(request));
func.Should().Throw <RpcException>();
}
public async Task RemoveUserFromRole_WithInvalidRole_ShouldThrowNotFoundRpcException()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.CreateAsync(user, "Pass@word1");
result.Succeeded.Should().BeTrue();
});
var request = new RemoveUserFromRoleRequest
{
UserId = user.Id.ToString(),
RoleName = "test"
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act Assert
var func = new Func <Task>(async() => await client.RemoveUserFromRoleAsync(request));
func.Should().Throw <RpcException>();
}
public async Task RemoveUserFromRole_ShouldBeOfTypeRemoveUserFromRoleResponse()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.CreateAsync(user, "Pass@word1");
result.Succeeded.Should().BeTrue();
});
await host.Server.UsingScopeAsync(
async scope =>
{
var roleService = scope.GetRequiredService <IRoleService>();
var result = await roleService.CreateAsync(
new Role
{
Name = AppRoles.Admin
});
result.Succeeded.Should().BeTrue();
});
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.AddToRoleAsync(await userService.FindByIdAsync(user.Id.ToString()), AppRoles.Admin);
result.Succeeded.Should().BeTrue();
});
var request = new RemoveUserFromRoleRequest
{
UserId = user.Id.ToString(),
RoleName = AppRoles.Admin
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act
var response = await client.RemoveUserFromRoleAsync(request);
// Assert
response.Should().BeOfType <RemoveUserFromRoleResponse>();
}
public ChallengeHistoryController(
IdentityService.IdentityServiceClient identityServiceClient,
ChallengeService.ChallengeServiceClient challengesServiceClient,
CashierService.CashierServiceClient cashierServiceClient
)
{
_identityServiceClient = identityServiceClient;
_challengesServiceClient = challengesServiceClient;
_cashierServiceClient = cashierServiceClient;
}
public ChallengesController(
IdentityService.IdentityServiceClient identityServiceClient,
ChallengeService.ChallengeServiceClient challengesServiceClient,
CashierService.CashierServiceClient cashierServiceClient,
GameService.GameServiceClient gameServiceClient
)
{
_identityServiceClient = identityServiceClient;
_challengesServiceClient = challengesServiceClient;
_cashierServiceClient = cashierServiceClient;
_gameServiceClient = gameServiceClient;
}
public async Task ReplaceUserClaim_ShouldBeOfTypeReplaceUserClaimResponse()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.CreateAsync(user, "Pass@word1");
result.Succeeded.Should().BeTrue();
});
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.AddClaimAsync(
await userService.FindByIdAsync(user.Id.ToString()),
new Claim(CustomClaimTypes.StripeCustomer, "customerId"));
result.Succeeded.Should().BeTrue();
});
var request = new ReplaceUserClaimRequest
{
UserId = user.Id.ToString(),
Claim = new UserClaimDto
{
Type = CustomClaimTypes.StripeCustomer,
Value = "customerId"
}
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act
var response = await client.ReplaceUserClaimAsync(request);
// Assert
response.Should().BeOfType <ReplaceUserClaimResponse>();
}
public async Task RemoveUserClaim_ShouldThrowFailedPreconditionRpcException()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.CreateAsync(user, "Pass@word1");
result.Succeeded.Should().BeTrue();
});
var request = new RemoveUserClaimRequest
{
UserId = user.Id.ToString(),
Claim = new UserClaimDto
{
Type = CustomClaimTypes.StripeCustomer,
Value = "customerId"
}
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act
var func = new Func <Task>(async() => await client.RemoveUserClaimAsync(request));
// Assert
func.Should().Throw <RpcException>();
}
public void RemoveUserFromRole_WithUserNull_ShouldThrowNotFoundRpcException()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
var request = new RemoveUserFromRoleRequest
{
UserId = user.Id.ToString(),
RoleName = "test"
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act Assert
var func = new Func <Task>(async() => await client.RemoveUserFromRoleAsync(request));
func.Should().Throw <RpcException>();
}
public void AddUserToRole_ShouldThrowNotFoundRpcException()
{
// Arrange
var userId = new UserId();
const string email = "*****@*****.**";
var claims = new[] { new Claim(JwtClaimTypes.Subject, userId.ToString()), new Claim(JwtClaimTypes.Email, email) };
var host = TestHost.WithClaimsFromBearerAuthentication(claims);
host.Server.CleanupDbContext();
var request = new AddUserToRoleRequest
{
UserId = userId,
RoleName = "test"
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act Assert
var func = new Func <Task>(async() => await client.AddUserToRoleAsync(request));
func.Should().Throw <RpcException>();
}
public void AddUserClaim_ShouldThrowFailedPreconditionRpcException()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
var request = new AddUserClaimRequest
{
UserId = user.Id.ToString()
};
// Act
var func = new Func <Task>(async() => await client.AddUserClaimAsync(request));
// Assert
func.Should().Throw <RpcException>();
}
public async Task Success()
{
// Arrange
var mockServiceBusPubliser = new Mock <IServiceBusPublisher>();
mockServiceBusPubliser.Setup(serviceBusPubliser => serviceBusPubliser.PublishAsync(It.IsAny <ChallengeParticipantRegisteredIntegrationEvent>()))
.Verifiable();
var user = new User
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
EmailConfirmed = true,
UserName = "******",
Country = Country.Canada
};
var account = new Account(user.Id.ConvertTo <UserId>());
var moneyAccount = new MoneyAccountDecorator(account);
moneyAccount.Deposit(Money.TwoHundred).MarkAsSucceeded();
var doxatag = new Doxatag(
account.Id,
"TestUser",
1000,
new UtcNowDateTimeProvider());
var gamePlayerId = new PlayerId();
var challenge = new Challenge(
new ChallengeId(),
new ChallengeName("TestChallenge"),
Game.LeagueOfLegends,
BestOf.One,
Entries.Two,
new ChallengeTimeline(new UtcNowDateTimeProvider(), ChallengeDuration.OneDay),
Scoring);
var payout = new ChallengePayoutFactory();
var challengePayout = new Cashier.Domain.AggregateModels.ChallengeAggregate.Challenge(
challenge.Id,
payout.CreateInstance().GetChallengePayout(ChallengePayoutEntries.One, MoneyEntryFee.OneHundred));
using var gamesHost = new GamesHostFactory().WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id));
gamesHost.Server.CleanupDbContext();
await gamesHost.Server.UsingScopeAsync(
async scope =>
{
var gameCredentialRepository = scope.GetRequiredService <IGameCredentialRepository>();
gameCredentialRepository.CreateCredential(
new Credential(
account.Id,
challenge.Game,
gamePlayerId,
new UtcNowDateTimeProvider()));
await gameCredentialRepository.UnitOfWork.CommitAsync(false);
});
var gameServiceClient = new GameService.GameServiceClient(gamesHost.CreateChannel());
using var challengesHost = new ChallengesHostFactory().WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id))
.WithWebHostBuilder(
builder =>
{
builder.ConfigureTestContainer <ContainerBuilder>(
container =>
{
container.RegisterInstance(mockServiceBusPubliser.Object).As <IServiceBusPublisher>().SingleInstance();
});
});
challengesHost.Server.CleanupDbContext();
await challengesHost.Server.UsingScopeAsync(
async scope =>
{
var challengeRepository = scope.GetRequiredService <IChallengeRepository>();
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync(false);
});
var challengeServiceClient = new ChallengeService.ChallengeServiceClient(challengesHost.CreateChannel());
using var cashierHost = new CashierHostFactory().WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id));
cashierHost.Server.CleanupDbContext();
await cashierHost.Server.UsingScopeAsync(
async scope =>
{
var accountRepository = scope.GetRequiredService <IAccountRepository>();
accountRepository.Create(account);
await accountRepository.CommitAsync();
});
await cashierHost.Server.UsingScopeAsync(
async scope =>
{
var challengeRepository = scope.GetRequiredService <IChallengePayoutRepository>();
challengeRepository.Create(challengePayout);
await challengeRepository.CommitAsync();
});
var cashierServiceClient = new CashierService.CashierServiceClient(cashierHost.CreateChannel());
using var identityHost = new IdentityHostFactory();
identityHost.Server.CleanupDbContext();
await identityHost.Server.UsingScopeAsync(
async scope =>
{
var doxatagRepository = scope.GetRequiredService <IUserService>();
await doxatagRepository.CreateAsync(user, "Pass@word1");
});
await identityHost.Server.UsingScopeAsync(
async scope =>
{
var doxatagRepository = scope.GetRequiredService <IDoxatagRepository>();
doxatagRepository.Create(doxatag);
await doxatagRepository.UnitOfWork.CommitAsync(false);
});
var identityServiceClient = new IdentityService.IdentityServiceClient(identityHost.CreateChannel());
using var challengesAggregatorHost = new ChallengesWebAggregatorHostFactory()
.WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id))
.WithWebHostBuilder(
builder =>
{
builder.ConfigureTestContainer <ContainerBuilder>(
container =>
{
container.RegisterInstance(challengeServiceClient).SingleInstance();
container.RegisterInstance(cashierServiceClient).SingleInstance();
container.RegisterInstance(identityServiceClient).SingleInstance();
container.RegisterInstance(gameServiceClient).SingleInstance();
});
});
var client = challengesAggregatorHost.CreateClient();
// Act
var response = await client.PostAsJsonAsync(
$"api/challenges/{challenge.Id}/participants",
new
{
});
// Assert
response.EnsureSuccessStatusCode();
mockServiceBusPubliser.Verify(
serviceBusPubliser => serviceBusPubliser.PublishAsync(It.IsAny <ChallengeParticipantRegisteredIntegrationEvent>()),
Times.Once);
}
static void Main(string[] args)
{
string host = "localhost";
//host = "34.229.211.196";
Channel channel = new Channel(host + ":32000", ChannelCredentials.Insecure);
var id = new IdentityService.IdentityServiceClient(channel);
Console.WriteLine("Key:");
var k = Console.ReadLine();
Console.WriteLine("Password:"******"Already exists.");
}
var authorization = id.ValidateIdentity(new ValidateIdentityRequest {
Key = k, Passcode = v
});
Console.WriteLine(authorization);
var client = new ChatService.ChatServiceClient(channel);
Console.WriteLine("listening");
using (var call = client.Listen(new ListenRequest()
{
SessionToken = Guid.NewGuid().ToString()
}))
{
var receiverTask = Task.Run(async() =>
{
while (await call.ResponseStream.MoveNext())
{
var message = call.ResponseStream.Current;
Console.WriteLine(message);
}
});
string newMessage;
do
{
newMessage = Console.ReadLine();
client.SendMessage(new SendMessageRequest {
Message = newMessage,
SessionToken = authorization.SessionToken
});
}while (!string.IsNullOrEmpty(newMessage));
}
// axicli identity login
// axicli chat [channel] [message ...]
channel.ShutdownAsync().Wait();
}
