public async Task ImportUsers()
{
var randomUser = TemporaryUserBuilder.RandomUserRecordArgs();
var args = new ImportUserRecordArgs()
{
Uid = randomUser.Uid,
Email = randomUser.Email,
DisplayName = "Random User",
PhotoUrl = "https://example.com/photo.png",
EmailVerified = true,
};
var usersLst = new List <ImportUserRecordArgs>()
{
args
};
var resp = await this.Auth.ImportUsersAsync(usersLst);
this.userBuilder.AddUid(randomUser.Uid);
Assert.Equal(1, resp.SuccessCount);
Assert.Equal(0, resp.FailureCount);
var user = await this.Auth.GetUserAsync(randomUser.Uid);
Assert.Equal(randomUser.Email, user.Email);
}
public async Task ImportUsers()
{
var randomUser = RandomUser.Create();
var args = new ImportUserRecordArgs()
{
Uid = randomUser.Uid,
Email = randomUser.Email,
DisplayName = "Random User",
PhotoUrl = "https://example.com/photo.png",
EmailVerified = true,
};
IEnumerable <ImportUserRecordArgs> usersLst = new List <ImportUserRecordArgs>();
usersLst = usersLst.Append(args);
var resp = await FirebaseAuth.DefaultInstance.ImportUsersAsync(usersLst);
try
{
Assert.Equal(1, resp.SuccessCount);
Assert.Equal(0, resp.FailureCount);
var user = await FirebaseAuth.DefaultInstance.GetUserAsync(randomUser.Uid);
Assert.Equal(randomUser.Email, user.Email);
}
finally
{
await FirebaseAuth.DefaultInstance.DeleteUserAsync(randomUser.Uid);
}
}
private async Task <string> ImportUserWithProviderAsync()
{
var randomArgs = TemporaryUserBuilder.RandomUserRecordArgs();
var importUser = new ImportUserRecordArgs()
{
Uid = randomArgs.Uid,
Email = randomArgs.Email,
PhoneNumber = randomArgs.PhoneNumber,
UserProviders = new List <UserProvider>()
{
new UserProvider()
{
Uid = $"google_{randomArgs.Uid}",
ProviderId = "google.com",
},
},
};
var result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(
new List <ImportUserRecordArgs>()
{
importUser,
});
Assert.Equal(1, result.SuccessCount);
this.userBuilder.AddUid(randomArgs.Uid);
return(randomArgs.Uid);
}
public void Serialize()
{
var userProviders = new List <UserProvider>
{
new UserProvider()
{
Uid = "google.uid",
ProviderId = "google.com",
},
};
var customClaims = new Dictionary <string, object>()
{
{ "admin", true },
};
var userMetadata = new UserMetadata(1, 2, null);
var passwordHash = Encoding.ASCII.GetBytes("secret");
var passwordSalt = Encoding.ASCII.GetBytes("salt");
var importUserRecordArgs = new ImportUserRecordArgs()
{
Uid = "123",
Email = "*****@*****.**",
EmailVerified = true,
DisplayName = "Example",
PhotoUrl = "http://example.com/photo",
PhoneNumber = "+11234567890",
Disabled = false,
UserMetadata = userMetadata,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
CustomClaims = customClaims,
UserProviders = userProviders,
};
var expected = new Dictionary <string, object>()
{
{ "createdAt", userMetadata.CreationTimestamp },
{ "customAttributes", JsonConvert.SerializeObject(customClaims) },
{ "disabled", false },
{ "displayName", "Example" },
{ "email", "*****@*****.**" },
{ "emailVerified", true },
{ "lastLoginAt", userMetadata.LastSignInTimestamp },
{ "passwordHash", JwtUtils.UrlSafeBase64Encode(passwordHash) },
{ "salt", JwtUtils.UrlSafeBase64Encode(passwordSalt) },
{ "phoneNumber", "+11234567890" },
{ "photoUrl", "http://example.com/photo" },
{ "providerUserInfo", userProviders.Select(userProvider => userProvider.ToRequest()) },
{ "localId", "123" },
};
Assert.Equal(
JsonConvert.SerializeObject(expected),
JsonConvert.SerializeObject(importUserRecordArgs.ToRequest()));
}
public void MissingUid()
{
var userRecordArgsWithMissingUid = new ImportUserRecordArgs()
{
};
Assert.Throws <ArgumentNullException>(
() => userRecordArgsWithMissingUid.ToRequest());
}
public void InvalidPhone()
{
var userProviderWithMissingUid = new ImportUserRecordArgs()
{
Uid = "123",
PhoneNumber = "11234567890",
};
Assert.Throws <ArgumentException>(
() => userProviderWithMissingUid.ToRequest());
}
public void InvalidEmail()
{
var userRecordArgsInvalidEmail = new ImportUserRecordArgs()
{
Uid = "123",
Email = "invalidemail",
};
Assert.Throws <ArgumentException>(
() => userRecordArgsInvalidEmail.ToRequest());
}
public void RequiredOnly()
{
var userRecordMinimal = new ImportUserRecordArgs()
{
Uid = "123",
};
var expected = new Dictionary <string, object>()
{
{ "localId", "123" },
};
Assert.Equal(
NewtonsoftJsonSerializer.Instance.Serialize(expected),
NewtonsoftJsonSerializer.Instance.Serialize(userRecordMinimal.ToRequest()));
}
public void ReservedCustomClaims()
{
foreach (var reservedKey in FirebaseTokenFactory.ReservedClaims)
{
var userProviderWithReservedClaimKey = new ImportUserRecordArgs()
{
Uid = "123",
CustomClaims = new Dictionary <string, object>()
{
{ reservedKey, "abc" },
},
};
Assert.Throws <ArgumentException>(
() => userProviderWithReservedClaimKey.ToRequest());
}
}
public async Task ImportUsersPasswordNoHash()
{
var args = new ImportUserRecordArgs()
{
Uid = "123",
Email = "*****@*****.**",
PasswordSalt = Encoding.ASCII.GetBytes("abc"),
PasswordHash = Encoding.ASCII.GetBytes("def"),
};
var usersLst = new List <ImportUserRecordArgs>()
{
args,
};
await Assert.ThrowsAsync <NullReferenceException>(
async() => await FirebaseAuth.DefaultInstance.ImportUsersAsync(usersLst));
}
public async Task ImportUsersWithPassword()
{
var randomUser = TemporaryUserBuilder.RandomUserRecordArgs();
var args = new ImportUserRecordArgs()
{
Uid = randomUser.Uid,
Email = randomUser.Email,
DisplayName = "Random User",
PhotoUrl = "https://example.com/photo.png",
EmailVerified = true,
PasswordSalt = Encoding.ASCII.GetBytes("NaCl"),
PasswordHash = Convert.FromBase64String("V358E8LdWJXAO7muq0CufVpEOXaj8aFiC7"
+ "T/rcaGieN04q/ZPJ08WhJEHGjj9lz/2TT+/86N5VjVoc5DdBhBiw=="),
CustomClaims = new Dictionary <string, object>()
{
{ "admin", true },
},
UserProviders = new List <UserProvider>
{
new UserProvider()
{
Uid = randomUser.Uid,
Email = randomUser.Email,
DisplayName = "John Doe",
PhotoUrl = "http://example.com/123/photo.png",
ProviderId = "google.com",
},
new UserProvider()
{
Uid = "fb.uid",
Email = "*****@*****.**",
DisplayName = "John Doe",
PhotoUrl = "http://example.com/123/photo.png",
ProviderId = "facebook.com",
},
},
};
var options = new UserImportOptions()
{
Hash = new Scrypt()
{
Key = Convert.FromBase64String("jxspr8Ki0RYycVU8zykbdLGjFQ3McFUH0uiiTvC"
+ "8pVMXAn210wjLNmdZJzxUECKbm0QsEmYUSDzZvpjeJ9WmXA=="),
SaltSeparator = Convert.FromBase64String("Bw=="),
Rounds = 8,
MemoryCost = 14,
},
};
var usersLst = new List <ImportUserRecordArgs>()
{
args
};
var resp = await this.Auth.ImportUsersAsync(usersLst, options);
this.userBuilder.AddUid(randomUser.Uid);
Assert.Equal(1, resp.SuccessCount);
Assert.Equal(0, resp.FailureCount);
var user = await this.Auth.GetUserAsync(randomUser.Uid);
Assert.Equal(randomUser.Email, user.Email);
var idToken = await AuthIntegrationUtils.SignInWithPasswordAsync(
randomUser.Email, "password", this.fixture.TenantId);
Assert.False(string.IsNullOrEmpty(idToken));
}
