public async Task CreateAsync_ShouldCreateUser()
{
// ARRANGE
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
var userStore = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleStore);
await userStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
var generalStore = userStore as IUserStore <DynamoIdentityUser>;
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
// ACT
await generalStore.CreateAsync(user, CancellationToken.None);
// ASSERT
var retrievedUser = await dbProvider.Context.LoadAsync(user);
Assert.NotNull(retrievedUser);
Assert.Equal(user.UserName, retrievedUser.UserName);
Assert.Equal(user.NormalizedUserName, retrievedUser.NormalizedUserName);
}
}
public async Task DynamoIdentityUser_ShouldSaveAndRetrieveTheFutureOccuranceCorrectly()
{
var lockoutEndDate = new DateTime(2018, 2, 1, 0, 0, 0, DateTimeKind.Utc).AddTicks(8996910);
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
user.LockUntil(lockoutEndDate);
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleUsers = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleUsers.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
var store = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleUsers);
await store.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
var retrievedUser = await dbProvider.Context.LoadAsync(user);
Assert.Equal(user.LockoutEndDate, retrievedUser.LockoutEndDate);
}
}
public async Task DynamoUserStore_ShouldPutThingsIntoUsersTableByDefault()
{
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
var store = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleStore);
await store.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
var tableNames = (await dbProvider.Client.ListTablesAsync()).TableNames;
var tableExists = tableNames.Any(x => x.Equals("users", StringComparison.Ordinal));
Assert.True(tableExists);
}
}
static void Main(string[] args)
{
/*
* This cli is only for bootstrapping the DB with
* an admin user.
* For all other cases, use the admin features in the
* auth service.
*
* # use cases:
* 2. Grant role to user
* 3. Remove role from user
* 4. Create admin role
*/
var loggerFactory = new LoggerFactory();
loggerFactory
.AddConsole()
.AddDebug();
var keyNormalizer = new UpperInvariantLookupNormalizer();
var roleUsersStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
var userStore = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleUsersStore);
var roleStore = new DynamoRoleStore <DynamoIdentityRole>();
var app = new CommandLineApplication();
app.HelpOption("-? | -h | --help");
var dbUrl = app.Option("-d|--dynamodb", "DynamoDB endpoint", CommandOptionType.SingleValue);
var region = app.Option("-R|--region", "AWS Region", CommandOptionType.SingleValue);
var tableNamePrefix = app.Option("-p|--prefix", "Table Name Prefix", CommandOptionType.SingleValue);
app.Command("role", roleCommand =>
{
roleCommand.HelpOption("-? | -h | --help");
var roleName = roleCommand.Option("-r|--role <role>", "role name", CommandOptionType.SingleValue);
roleCommand.Command("add", addRole =>
{
addRole.HelpOption("-? | -h | --help");
addRole.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
program.CreateRole(roleName.Value()).Wait();
return(0);
});
});
roleCommand.Command("remove", removeRole =>
{
removeRole.HelpOption("-? | -h | --help");
removeRole.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
program.RemoveRole(roleName.Value()).Wait();
return(0);
});
});
});
app.Command("claim", claimCommand =>
{
claimCommand.HelpOption("-? | -h | --help");
var roleName = claimCommand.Option("-r|--role <role>", "role name", CommandOptionType.SingleValue);
var claimType = claimCommand.Option("-t|--claim-type <type>", "claim type", CommandOptionType.SingleValue);
var claimValue = claimCommand.Option("-v|--claim-value <value>", "claim value", CommandOptionType.SingleValue);
claimCommand.Command("get", getClaims =>
{
getClaims.HelpOption("-? | -h | --help");
getClaims.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
var claims = program.GetClaims(roleName.Value()).Result;
Console.WriteLine(JsonConvert.SerializeObject(claims, Formatting.Indented));
return(0);
});
});
claimCommand.Command("add", addClaim =>
{
addClaim.HelpOption("-? | -h | --help");
addClaim.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
var claim = new Claim(claimType.Value(), claimValue.Value());
program.AddClaim(roleName.Value(), claim).Wait();
return(0);
});
});
claimCommand.Command("remove", removeClaim =>
{
removeClaim.HelpOption("-? | -h | --help");
removeClaim.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
var claim = new Claim(claimType.Value(), claimValue.Value());
program.RemoveClaim(roleName.Value(), claim).Wait();
return(0);
});
});
});
app.Execute(args);
}
public Program(ILoggerFactory loggerFactory,
DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole> userStore,
DynamoRoleStore <DynamoIdentityRole> roleStore,
DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser> roleUsersStore,
ILookupNormalizer keyNormalizer,
string dbUrl,
string regionName,
string tableNamePrefix)
{
this.logger = loggerFactory.CreateLogger <Program>();
this.userStore = userStore;
this.roleStore = roleStore;
this.roleUsersStore = roleUsersStore;
this.keyNormalizer = keyNormalizer;
var dbConfig = new AmazonDynamoDBConfig
{
ServiceURL = dbUrl
};
if (regionName != null)
{
var region = RegionEndpoint.GetBySystemName(regionName);
dbConfig.RegionEndpoint = region;
}
var client = new AmazonDynamoDBClient(dbConfig);
var contextConfig = new DynamoDBContextConfig
{
TableNamePrefix = tableNamePrefix
};
var context = new DynamoDBContext(client, contextConfig);
var prefix = tableNamePrefix ?? "";
roleUsersTableName = $"{prefix}roleUsers";
usersTableName = $"{prefix}users";
rolesTableName = $"{prefix}roles";
var tables = client.ListTablesAsync().Result;
if (!tables.TableNames.Contains(usersTableName))
{
throw new Exception($"can't find table {usersTableName}");
}
if (!tables.TableNames.Contains(rolesTableName))
{
throw new Exception($"can't find table {rolesTableName}");
}
if (!tables.TableNames.Contains(roleUsersTableName))
{
throw new Exception($"can't find table {roleUsersTableName}");
}
roleUsersStore.EnsureInitializedAsync(client, context, roleUsersTableName).Wait();
userStore.EnsureInitializedAsync(client, context, usersTableName).Wait();
roleStore.EnsureInitializedAsync(client, context, rolesTableName).Wait();
}
public async Task DynamoIdentityUser_CanBeSavedAndRetrieved_WhenItBecomesTheSubclass()
{
var username = TestUtils.RandomString(10);
var email = TestUtils.RandomString(10);
var countryName = TestUtils.RandomString(10);
var loginProvider = TestUtils.RandomString(5);
var providerKey = TestUtils.RandomString(5);
var displayName = TestUtils.RandomString(5);
var myCustomThing = TestUtils.RandomString(10);
var user = new MyIdentityUser(username)
{
MyCustomThing = myCustomThing
};
var claim = new Claim(ClaimTypes.Country, countryName);
user.AddClaim(claim);
var login = new UserLoginInfo(loginProvider, providerKey, displayName);
user.AddLogin(login);
user.SetEmail(email);
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleUsersStore = new DynamoRoleUsersStore <DynamoIdentityRole, MyIdentityUser>();
await roleUsersStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
var store = new DynamoUserStore <MyIdentityUser, DynamoIdentityRole>(roleUsersStore);
await store.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
// ACT, ASSERT
var result = await store.CreateAsync(user, CancellationToken.None);
Assert.True(result.Succeeded);
// ACT, ASSERT
var retrievedUser = await store.FindByIdAsync(user.Id, CancellationToken.None);
Assert.NotNull(retrievedUser);
Assert.Equal(username, retrievedUser.UserName);
Assert.Equal(myCustomThing, retrievedUser.MyCustomThing);
var countryClaim = retrievedUser.GetClaims().FirstOrDefault(x => x.Type == ClaimTypes.Country);
Assert.NotNull(countryClaim);
Assert.Equal(countryName, countryClaim.Value);
var retrievedLoginProvider = retrievedUser.GetLogins().FirstOrDefault(x => x.LoginProvider == loginProvider);
Assert.NotNull(retrievedLoginProvider);
Assert.Equal(providerKey, retrievedLoginProvider.ProviderKey);
Assert.Equal(displayName, retrievedLoginProvider.ProviderDisplayName);
var userByLogin = await store.FindByLoginAsync(loginProvider, providerKey, CancellationToken.None);
Assert.NotNull(userByLogin);
var retrivedLogins = userByLogin.GetLogins();
Assert.NotEmpty(retrivedLogins);
Assert.True(retrivedLogins[0].EqualsTo(login));
var userByEmail = await store.FindByEmailAsync(user.NormalizedEmail, CancellationToken.None);
Assert.NotNull(userByEmail);
var retrievedEmail = userByEmail.Email.Value;
Assert.NotEmpty(retrievedEmail);
Assert.True(retrievedEmail.Equals(email));
var userByName = await store.FindByNameAsync(user.NormalizedUserName, CancellationToken.None);
Assert.NotNull(userByName);
var retrievedUserName = userByName.UserName;
Assert.NotEmpty(retrievedUserName);
Assert.True(retrievedUserName.Equals(username));
var usersForClaims = await store.GetUsersForClaimAsync(claim, CancellationToken.None);
Assert.NotNull(usersForClaims);
Assert.NotEmpty(usersForClaims);
var userByClaim = usersForClaims[0];
Assert.NotNull(userByClaim);
var userClaims = userByClaim.GetClaims();
Assert.NotNull(userClaims);
Assert.NotEmpty(userClaims);
Assert.Equal(userClaims[0].Type, claim.Type);
Assert.Equal(userClaims[0].Value, claim.Value);
}
}
