public void Write_Success()
{
var json = JsonSerializer.Serialize(new TestObject
{
StringProp = "1",
EnumerableStringProp = new List <string>
{
"2",
"3",
},
});
var jsonElement = JsonDocument.Parse(json).RootElement;
var stringProp = AssertHelper.AssertJsonProperty(jsonElement, "StringProp", JsonValueKind.String);
Assert.Equal("1", stringProp.GetString());
var list = AssertHelper.AssertJsonProperty(jsonElement, "EnumerableStringProp", JsonValueKind.Array);
Assert.Equal(2, list.GetArrayLength());
var firstElement = list[0];
Assert.Equal(JsonValueKind.String, firstElement.ValueKind);
Assert.Equal("2", firstElement.GetString());
var secondElement = list[1];
Assert.Equal(JsonValueKind.String, secondElement.ValueKind);
Assert.Equal("3", secondElement.GetString());
}
public async Task TokenEndpoint_GrantTypePassword_NoAuthEmailHeader_Fails()
{
var deviceId = "92b9d953-b9b6-4eaf-9d3e-11d57144dfeb";
var username = "******";
await _factory.RegisterAsync(new RegisterRequestModel
{
Email = username,
MasterPasswordHash = "master_password_hash",
});
var context = await _factory.Server.PostAsync("/connect/token", new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "scope", "api offline_access" },
{ "client_id", "web" },
{ "deviceType", DeviceTypeAsString(DeviceType.FirefoxBrowser) },
{ "deviceIdentifier", deviceId },
{ "deviceName", "firefox" },
{ "grant_type", "password" },
{ "username", username },
{ "password", "master_password_hash" },
}));
Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode);
var body = await AssertHelper.AssertResponseTypeIs <JsonDocument>(context);
var root = body.RootElement;
var error = AssertHelper.AssertJsonProperty(root, "error", JsonValueKind.String).GetString();
Assert.Equal("invalid_grant", error);
AssertHelper.AssertJsonProperty(root, "error_description", JsonValueKind.String);
}
private static int AssertExpiresIn(JsonElement tokenResponse, int expectedExpiresIn = 3600)
{
var expiresIn = AssertHelper.AssertJsonProperty(tokenResponse, "expires_in", JsonValueKind.Number).GetInt32();
Assert.Equal(expectedExpiresIn, expiresIn);
return(expiresIn);
}
public void GetTwoFactorProviders_SavedWithName_Success()
{
var user = new User();
// This should save items with the string name of the enum and we will validate that we can read
// from that just incase some users have it saved that way.
user.TwoFactorProviders = JsonSerializer.Serialize(_testTwoFactorConfig);
// Preliminary Asserts to make sure we are testing what we want to be testing
using var jsonDocument = JsonDocument.Parse(user.TwoFactorProviders);
var root = jsonDocument.RootElement;
// This means it saved the enum as its string name
AssertHelper.AssertJsonProperty(root, "WebAuthn", JsonValueKind.Object);
AssertHelper.AssertJsonProperty(root, "Email", JsonValueKind.Object);
// Actual checks
var twoFactorProviders = user.GetTwoFactorProviders();
var webAuthn = Assert.Contains(TwoFactorProviderType.WebAuthn, (IDictionary <TwoFactorProviderType, TwoFactorProvider>)twoFactorProviders);
Assert.True(webAuthn.Enabled);
Assert.NotNull(webAuthn.MetaData);
var webAuthnMetaDataItem = Assert.Contains("Item", (IDictionary <string, object>)webAuthn.MetaData);
Assert.Equal("thing", webAuthnMetaDataItem);
var email = Assert.Contains(TwoFactorProviderType.Email, (IDictionary <TwoFactorProviderType, TwoFactorProvider>)twoFactorProviders);
Assert.False(email.Enabled);
Assert.NotNull(email.MetaData);
var emailMetaDataEmail = Assert.Contains("Email", (IDictionary <string, object>)email.MetaData);
Assert.Equal("*****@*****.**", emailMetaDataEmail);
}
public void GetTwoFactorProviders_SavedWithName_Success()
{
var organization = new Organization();
// This should save items with the string name of the enum and we will validate that we can read
// from that just incase some organizations have it saved that way.
organization.TwoFactorProviders = JsonSerializer.Serialize(_testConfig);
// Preliminary Asserts to make sure we are testing what we want to be testing
using var jsonDocument = JsonDocument.Parse(organization.TwoFactorProviders);
var root = jsonDocument.RootElement;
// This means it saved the enum as its string name
AssertHelper.AssertJsonProperty(root, "OrganizationDuo", JsonValueKind.Object);
// Actual checks
var twoFactorProviders = organization.GetTwoFactorProviders();
var duo = Assert.Contains(TwoFactorProviderType.OrganizationDuo, (IDictionary <TwoFactorProviderType, TwoFactorProvider>)twoFactorProviders);
Assert.True(duo.Enabled);
Assert.NotNull(duo.MetaData);
var iKey = Assert.Contains("IKey", (IDictionary <string, object>)duo.MetaData);
Assert.Equal("IKey_value", iKey);
var sKey = Assert.Contains("SKey", (IDictionary <string, object>)duo.MetaData);
Assert.Equal("SKey_value", sKey);
var host = Assert.Contains("Host", (IDictionary <string, object>)duo.MetaData);
Assert.Equal("Host_value", host);
}
public void Write_Null()
{
// When the values are null the converters aren't actually ran and it automatically serializes null
var json = JsonSerializer.Serialize(new TestObject
{
StringProp = null,
EnumerableStringProp = null,
});
var jsonElement = JsonDocument.Parse(json).RootElement;
AssertHelper.AssertJsonProperty(jsonElement, "StringProp", JsonValueKind.Null);
AssertHelper.AssertJsonProperty(jsonElement, "EnumerableStringProp", JsonValueKind.Null);
}
public void ToSend_Text_Success()
{
var deletionDate = DateTime.UtcNow.AddDays(5);
var sendRequest = new SendRequestModel
{
DeletionDate = deletionDate,
Disabled = false,
ExpirationDate = null,
HideEmail = false,
Key = "encrypted_key",
MaxAccessCount = null,
Name = "encrypted_name",
Notes = null,
Password = "******",
Text = new SendTextModel()
{
Hidden = false,
Text = "encrypted_text"
},
Type = SendType.Text,
};
var sendService = Substitute.For <ISendService>();
sendService.HashPassword(Arg.Any <string>())
.Returns((info) => $"hashed_{(string)info[0]}");
var send = sendRequest.ToSend(Guid.NewGuid(), sendService);
Assert.Equal(deletionDate, send.DeletionDate);
Assert.False(send.Disabled);
Assert.Null(send.ExpirationDate);
Assert.False(send.HideEmail);
Assert.Equal("encrypted_key", send.Key);
Assert.Equal("hashed_Password", send.Password);
using var jsonDocument = JsonDocument.Parse(send.Data);
var root = jsonDocument.RootElement;
var text = AssertHelper.AssertJsonProperty(root, "Text", JsonValueKind.String).GetString();
Assert.Equal("encrypted_text", text);
AssertHelper.AssertJsonProperty(root, "Hidden", JsonValueKind.False);
Assert.False(root.TryGetProperty("Notes", out var _));
var name = AssertHelper.AssertJsonProperty(root, "Name", JsonValueKind.String).GetString();
Assert.Equal("encrypted_name", name);
}
public void Serialize_Success()
{
var sut = new SendFileData
{
Id = "test",
Size = 100,
FileName = "thing.pdf",
Validated = true,
};
var json = JsonSerializer.Serialize(sut);
var document = JsonDocument.Parse(json);
var root = document.RootElement;
AssertHelper.AssertJsonProperty(root, "Size", JsonValueKind.String);
Assert.False(root.TryGetProperty("SizeString", out _));
}
public void Write_Empty()
{
// When the values are null the converters aren't actually ran and it automatically serializes null
var json = JsonSerializer.Serialize(new TestObject
{
StringProp = "",
EnumerableStringProp = Enumerable.Empty <string>(),
});
var jsonElement = JsonDocument.Parse(json).RootElement;
var stringVal = AssertHelper.AssertJsonProperty(jsonElement, "StringProp", JsonValueKind.String).GetString();
Assert.Equal("", stringVal);
var array = AssertHelper.AssertJsonProperty(jsonElement, "EnumerableStringProp", JsonValueKind.Array);
Assert.Equal(0, array.GetArrayLength());
}
public async Task TokenEndpoint_GrantTypeClientCredentials_AsInstallation_NoIdPart_Fails()
{
var context = await _factory.Server.PostAsync("/connect/token", new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "grant_type", "client_credentials" },
{ "client_id", "installation." },
{ "client_secret", "something" },
{ "scope", "api.push" },
}));
Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode);
var errorBody = await AssertHelper.AssertResponseTypeIs <JsonDocument>(context);
var error = AssertHelper.AssertJsonProperty(errorBody.RootElement, "error", JsonValueKind.String).GetString();
Assert.Equal("invalid_client", error);
}
public async Task UpdateLicenseAsync_Success(SutProvider <UserService> sutProvider,
User user, UserLicense userLicense)
{
using var tempDir = new TempDirectory();
var now = DateTime.UtcNow;
userLicense.Issued = now.AddDays(-10);
userLicense.Expires = now.AddDays(10);
userLicense.Version = 1;
userLicense.Premium = true;
user.EmailVerified = true;
user.Email = userLicense.Email;
sutProvider.GetDependency <Settings.IGlobalSettings>().SelfHosted = true;
sutProvider.GetDependency <Settings.IGlobalSettings>().LicenseDirectory = tempDir.Directory;
sutProvider.GetDependency <ILicensingService>()
.VerifyLicense(userLicense)
.Returns(true);
await sutProvider.Sut.UpdateLicenseAsync(user, userLicense);
var filePath = Path.Combine(tempDir.Directory, "user", $"{user.Id}.json");
Assert.True(File.Exists(filePath));
var document = JsonDocument.Parse(File.OpenRead(filePath));
var root = document.RootElement;
Assert.Equal(JsonValueKind.Object, root.ValueKind);
// Sort of a lazy way to test that it is indented but not sure of a better way
Assert.Contains('\n', root.GetRawText());
AssertHelper.AssertJsonProperty(root, "LicenseKey", JsonValueKind.String);
AssertHelper.AssertJsonProperty(root, "Id", JsonValueKind.String);
AssertHelper.AssertJsonProperty(root, "Premium", JsonValueKind.True);
var versionProp = AssertHelper.AssertJsonProperty(root, "Version", JsonValueKind.Number);
Assert.Equal(1, versionProp.GetInt32());
}
public void SetTwoFactorProviders_Success()
{
var organization = new Organization();
organization.SetTwoFactorProviders(_testConfig);
using var jsonDocument = JsonDocument.Parse(organization.TwoFactorProviders);
var root = jsonDocument.RootElement;
var duo = AssertHelper.AssertJsonProperty(root, "6", JsonValueKind.Object);
AssertHelper.AssertJsonProperty(duo, "Enabled", JsonValueKind.True);
var duoMetaData = AssertHelper.AssertJsonProperty(duo, "MetaData", JsonValueKind.Object);
var iKey = AssertHelper.AssertJsonProperty(duoMetaData, "IKey", JsonValueKind.String).GetString();
Assert.Equal("IKey_value", iKey);
var sKey = AssertHelper.AssertJsonProperty(duoMetaData, "SKey", JsonValueKind.String).GetString();
Assert.Equal("SKey_value", sKey);
var host = AssertHelper.AssertJsonProperty(duoMetaData, "Host", JsonValueKind.String).GetString();
Assert.Equal("Host_value", host);
}
public void SetTwoFactorProviders_Success()
{
var user = new User();
user.SetTwoFactorProviders(_testTwoFactorConfig);
using var jsonDocument = JsonDocument.Parse(user.TwoFactorProviders);
var root = jsonDocument.RootElement;
var webAuthn = AssertHelper.AssertJsonProperty(root, "7", JsonValueKind.Object);
AssertHelper.AssertJsonProperty(webAuthn, "Enabled", JsonValueKind.True);
var webMetaData = AssertHelper.AssertJsonProperty(webAuthn, "MetaData", JsonValueKind.Object);
AssertHelper.AssertJsonProperty(webMetaData, "Item", JsonValueKind.String);
var email = AssertHelper.AssertJsonProperty(root, "1", JsonValueKind.Object);
AssertHelper.AssertJsonProperty(email, "Enabled", JsonValueKind.False);
var emailMetaData = AssertHelper.AssertJsonProperty(email, "MetaData", JsonValueKind.Object);
AssertHelper.AssertJsonProperty(emailMetaData, "Email", JsonValueKind.String);
}
public async Task TokenEndpoint_GrantTypePassword_Success()
{
var deviceId = "92b9d953-b9b6-4eaf-9d3e-11d57144dfeb";
var username = "******";
await _factory.RegisterAsync(new RegisterRequestModel
{
Email = username,
MasterPasswordHash = "master_password_hash"
});
var context = await _factory.Server.PostAsync("/connect/token", new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "scope", "api offline_access" },
{ "client_id", "web" },
{ "deviceType", DeviceTypeAsString(DeviceType.FirefoxBrowser) },
{ "deviceIdentifier", deviceId },
{ "deviceName", "firefox" },
{ "grant_type", "password" },
{ "username", username },
{ "password", "master_password_hash" },
}), context => context.SetAuthEmail(username));
using var body = await AssertDefaultTokenBodyAsync(context);
var root = body.RootElement;
AssertRefreshTokenExists(root);
AssertHelper.AssertJsonProperty(root, "ForcePasswordReset", JsonValueKind.False);
AssertHelper.AssertJsonProperty(root, "ResetMasterPassword", JsonValueKind.False);
var kdf = AssertHelper.AssertJsonProperty(root, "Kdf", JsonValueKind.Number).GetInt32();
Assert.Equal(0, kdf);
var kdfIterations = AssertHelper.AssertJsonProperty(root, "KdfIterations", JsonValueKind.Number).GetInt32();
Assert.Equal(5000, kdfIterations);
}
private static void AssertTokenType(JsonElement tokenResponse)
{
var tokenTypeProperty = AssertHelper.AssertJsonProperty(tokenResponse, "token_type", JsonValueKind.String).GetString();
Assert.Equal("Bearer", tokenTypeProperty);
}
private static string AssertRefreshTokenExists(JsonElement tokenResponse)
{
return(AssertHelper.AssertJsonProperty(tokenResponse, "refresh_token", JsonValueKind.String).GetString());
}
private static string AssertScopeExists(JsonElement tokenResponse)
{
return(AssertHelper.AssertJsonProperty(tokenResponse, "scope", JsonValueKind.String).GetString());
}
