public FileStream Write(BtsApplication btsApplication, Resource[] resources)
{
BtsApplicationValidator.Validate(btsApplication);
ResourceValidator.Validate(resources);
var cabFileWriter = new CabFileWriter();
var cabFolderPath = cabFileWriter.Write(resources);
btsApplication.AddDefaultApplicationReference();
var adfFileWriter = new AdfFileWriter();
var adfFilePath = adfFileWriter.Write(btsApplication, resources);
var msiFilePath = MsiFileWriter.Write();
var productCode = Guid.NewGuid();
var upgradeCode = Guid.NewGuid();
var properties = MsiFileWriter.GetProperties(btsApplication.Name, productCode, upgradeCode);
using (var db = new Database(msiFilePath, DatabaseOpenMode.Direct))
{
db.UpdateSummaryInfo();
db.UpdateUpgradeTable(upgradeCode);
db.UpdateProperties(properties);
db.UpdateFileContent(cabFolderPath, adfFilePath, resources.Length);
db.MakeCustomModifications(productCode, btsApplication.Name);
db.Commit();
}
File.Delete(adfFilePath);
Directory.Delete(cabFolderPath, true);
return(File.OpenRead(msiFilePath));
}
public void IsValidFileResource_WithOneStringParameter_IfThePathExistsAndThePathIsToAnEmptyFile_ShouldReturnFalse()
{
const string path = @"Q:\Test";
var resourceValidator = new ResourceValidator(this.CreateFileSystem(null, true, path));
Assert.IsFalse(resourceValidator.IsValidFileResource(path));
}
public void ResourceWithNoMimeTypeIsInvalid()
{
var alert = CreateInfoWithResourceWithDescriptionAndMimeType("Description", null);
var resourceValidator = new ResourceValidator(alert);
Assert.False(resourceValidator.IsValid);
}
public void IsValidFileResource_WithOneStringParameter_IfThePathExistsAndThePathIsToAFileThatContainsXml_ShouldReturnTrue()
{
const string path = @"Q:\Test";
var resourceValidator = new ResourceValidator(this.CreateFileSystem("<root />", true, path));
Assert.IsTrue(resourceValidator.IsValidFileResource(path));
}
public void ResourceWithoutMimeTypeAndDescriptionHasTwoErrors()
{
var alert = CreateInfoWithResourceWithDescriptionAndMimeType(null, null);
var resourceValidator = new ResourceValidator(alert);
Assert.False(resourceValidator.IsValid);
}
public void IsValidEmbeddedResource_IfTheAssemblyDoesNotContainTheResourceName_ShouldReturnFalse()
{
var assembly = this.CreateAssembly("Resource");
var resourceValidator = new ResourceValidator(Mock.Of <IFileSystem>());
Assert.IsFalse(resourceValidator.IsValidEmbeddedResource(assembly, "AnotherResource"));
}
public void IsValidEmbeddedResource_IfTheAssemblyContainsTheResourceNameAndTheResourceDoesNotContainXml_ShouldReturnFalse()
{
const string resourceName = "Resource";
var assembly = this.CreateAssembly("Test", resourceName);
var resourceValidator = new ResourceValidator(Mock.Of <IFileSystem>());
Assert.IsFalse(resourceValidator.IsValidEmbeddedResource(assembly, resourceName));
}
public void ResourceWithDescriptionAndMimeTypeIsValid()
{
var info = CreateInfoWithResourceWithDescriptionAndMimeType("Description", "image/jpeg");
var resourceValidator = new ResourceValidator(info);
Assert.True(resourceValidator.IsValid);
Assert.Equal(0, resourceValidator.Errors.Count());
}
public void AllActionsValidForResources(CRN resource, ResourceAction action)
{
// Arrange
var storage = new MockResourceStorage().Setup();
var resourceValidator = new ResourceValidator(storage);
// Act
var result = resourceValidator.Validate(resource, action);
// Assert
result.IsValid.Should().BeTrue();
}
public void AllResourcesAreInvalid(CRN resource)
{
// Arrange
var storage = new MockResourceStorage().Setup();
var resourceValidator = new ResourceValidator(storage);
// Act
var result = resourceValidator.Validate(resource);
// Assert
result.IsValid.Should().BeFalse();
}
public void ValidateEntries(Profile profile, IEnumerable <Feed.Entry> entries, ReportMode mode)
{
ResourceValidator validator = new ResourceValidator(profile);
foreach (Feed.Entry entry in entries)
{
printer.Title(string.Format("Validating resource '{0}'", entry.Title));
Report report = validator.Validate(entry.ResourceNode);
printer.Print(report, mode);
Console.Write(".");
}
}
public void AllResourcesAreValid(Resource resource)
{
// Arrange
var storage = new MockResourceStorage().Setup();
var resourceValidator = new ResourceValidator(storage);
// Act
var result = resourceValidator.Validate(resource.Identifier);
// Assert
result.IsValid.Should().BeTrue();
}
IPermissionValidator GetValidator()
{
var resourceStorage = new MockResourceStorage().Setup();
var permissionStorage = new MockPermissionGrantStorage().Setup();
var resourceFinder = new ResourceFinder(resourceStorage);
var resourceValidator = new ResourceValidator(resourceStorage);
var permissionFinder = new PermissionGrantFinder(permissionStorage);
var dataProviderStorage = new MockDataProviderStorage().Setup();
var principalStorage = new MockPrincipalStorage().Setup();
var policyApplicator = new DataProviderPolicyApplicator(dataProviderStorage, principalStorage);
return(new PermissionValidator(resourceValidator, resourceFinder, permissionFinder, policyApplicator));
}
public PermissionGrantManagerTests()
{
var dataProviderStorage = new MockDataProviderStorage().Setup();
var principalStorage = new MockPrincipalStorage().Setup();
var applicator = new DataProviderPolicyApplicator(dataProviderStorage, principalStorage);
var permissionGrantStorage = new MockPermissionGrantStorage().Setup();
var permissionGrantFinder = new PermissionGrantFinder(permissionGrantStorage);
var resourceStorage = new MockResourceStorage().Setup();
var resourceValidator = new ResourceValidator(resourceStorage);
var resourceFinder = new ResourceFinder(resourceStorage);
var validator = new PermissionValidator(resourceValidator, resourceFinder, permissionGrantFinder, applicator);
this.manager = new PermissionGrantManager(applicator, permissionGrantStorage, validator, resourceStorage);
}
private void InsertProcedural(IProceduralEntityResource resource, ResourceValidator validator)
{
var attribute = new RESTableProceduralAttribute(resource.Methods)
{
Description = resource.Description
};
var type = resource.Type;
validator.ValidateRuntimeInsertion(type, resource.Name, attribute);
validator.Validate(type);
var inserted = _InsertResource(type, resource.Name, attribute);
ReceiveClaimed(new[] { inserted });
}
public void ResourceWithUriAndNoSizeIsInvalid()
{
var info = new Info();
var resource = new Resource();
resource.Uri = new System.Uri("http://www.google.ro");
resource.Size = null;
info.Resources.Add(resource);
var resourceValidator = new ResourceValidator(info);
Assert.False(resourceValidator.IsValid);
var sizeErrors = from error in resourceValidator.Errors
where error.GetType() == typeof(SizeRequiredError)
select error;
Assert.NotEmpty(sizeErrors);
}
public void IsValidEmbeddedResource_IfTheAssemblyParameterIsNull_ShouldThrowAnArgumentNullException()
{
var resourceValidator = new ResourceValidator(Mock.Of <IFileSystem>());
try
{
resourceValidator.IsValidEmbeddedResource(null, "Test");
}
catch (ArgumentNullException argumentNullException)
{
if (argumentNullException.ParamName.Equals("assembly", StringComparison.Ordinal))
{
throw;
}
}
}
public async override Task <DeviceAuthorizationRequestValidationResult> Validate(NameValueCollection parameters, string accessToken = null)
{
Logger.LogDebug($"{nameof(DeviceAuthorizationRequestValidator)}: Started trusted device authorization request validation.");
// Validate that the consumer specified all required parameters.
var parametersToValidate = new[] {
RegistrationRequestParameters.ClientId,
RegistrationRequestParameters.CodeChallenge,
RegistrationRequestParameters.DeviceId,
RegistrationRequestParameters.Scope
};
foreach (var parameter in parametersToValidate)
{
var parameterValue = parameters.Get(parameter);
if (string.IsNullOrWhiteSpace(parameterValue))
{
return(Error(OidcConstants.TokenErrors.InvalidRequest, $"Parameter '{parameter}' is not specified."));
}
}
// Load device.
var device = await UserDeviceStore.GetByDeviceId(parameters.Get(RegistrationRequestParameters.DeviceId));
if (device == null || !device.SupportsFingerprintLogin)
{
return(Error(OidcConstants.TokenErrors.InvalidRequest, "Device cannot initiate fingerprint login."));
}
// Load and validate client.
var client = await LoadClient(parameters.Get(RegistrationRequestParameters.ClientId));
if (client == null)
{
return(Error(OidcConstants.AuthorizeErrors.UnauthorizedClient, "Client is unknown or not enabled."));
}
if (client.ProtocolType != IdentityServerConstants.ProtocolTypes.OpenIdConnect)
{
return(Error(OidcConstants.AuthorizeErrors.UnauthorizedClient, "Invalid protocol."));
}
// Validate requested scopes.
var isOpenIdRequest = false;
var requestedScopes = parameters.Get(RegistrationRequestParameters.Scope).Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (requestedScopes.Contains(IdentityServerConstants.StandardScopes.OpenId))
{
isOpenIdRequest = true;
}
var validatedResources = await ResourceValidator.ValidateRequestedResourcesAsync(new ResourceValidationRequest {
Client = client,
Scopes = requestedScopes
});
if (!validatedResources.Succeeded)
{
return(Error(OidcConstants.AuthorizeErrors.InvalidScope, "Invalid scope."));
}
if (validatedResources.Resources.IdentityResources.Any() && !isOpenIdRequest)
{
return(Error(OidcConstants.AuthorizeErrors.InvalidScope, "Identity scopes requested, but openid scope is missing."));
}
// Finally return result.
return(new DeviceAuthorizationRequestValidationResult {
IsError = false,
Client = client,
CodeChallenge = parameters.Get(RegistrationRequestParameters.CodeChallenge),
Device = device,
InteractionMode = InteractionMode.Fingerprint,
IsOpenIdRequest = isOpenIdRequest,
RequestedScopes = requestedScopes,
UserId = device.UserId
});
}
