public CrudService(
AnyServiceConfig config,
IRepository <TEntity> repository,
CrudValidatorBase <TEntity> validator,
WorkContext workContext,
IModelPreparar <TEntity> modelPreparar,
IEventBus eventBus,
IFileStoreManager fileStoreManager,
IFilterFactory filterFactory,
IPermissionManager permissionManager,
IEnumerable <EntityConfigRecord> entityConfigRecords,
ILogger <CrudService <TEntity> > logger)
{
Logger = logger;
Config = config;
Repository = repository;
Validator = validator;
WorkContext = workContext;
ModelPreparar = modelPreparar;
EventBus = eventBus;
FileStorageManager = fileStoreManager;
FilterFactory = filterFactory;
PermissionManager = permissionManager;
CurrentEntityConfigRecord = entityConfigRecords.First(typeof(TEntity));
}
public async Task UserIdIsNull_ReturnUnauthroized()
{
var logger = new Mock <ILogger <WorkContextMiddleware> >();
var ecr = new EntityConfigRecord
{
EndpointSettings = new EndpointSettings
{
Route = "/some-resource",
GetSettings = new EndpointMethodSettings {
Disabled = true
},
PutSettings = new EndpointMethodSettings {
Disabled = true
},
},
Type = typeof(string),
};
var entityConfigRecords = new[] { ecr };
var wcm = new WorkContextMiddleware(null, entityConfigRecords, logger.Object);
var user = new Mock <ClaimsPrincipal>();
user.Setup(u => u.Claims).Returns(new Claim[] { });
var ctx = new Mock <HttpContext>();
ctx.SetupGet(r => r.Request.Headers).Returns(new HeaderDictionary());
var res = new Mock <HttpResponse>();
ctx.Setup(h => h.User).Returns(user.Object);
ctx.Setup(h => h.Response).Returns(res.Object);
var wc = new WorkContext();
await wcm.InvokeAsync(ctx.Object, wc);
res.VerifySet(r => r.StatusCode = StatusCodes.Status401Unauthorized, Times.Once);
}
public void EntityCreatedHandler_UpdatesExistsUserPermissions()
{
var expPr = new PermissionRecord("c", "r", "u", "d");
var ecr = new EntityConfigRecord {
Type = typeof(TestClass), PermissionRecord = expPr
};
var sp = new Mock <IServiceProvider>();
sp.Setup(s => s.GetService(typeof(IEnumerable <EntityConfigRecord>))).Returns(new[] { ecr });
var userId = "uId";
var dbUp = new UserPermissions
{
UserId = userId,
EntityPermissions = new[] {
new EntityPermission
{
EntityId = "eId",
EntityKey = "ek",
PermissionKeys = new[] { "r1", "u1", "d1", },
},
}
};
var pm = new Mock <IPermissionManager>();
pm.Setup(p => p.GetUserPermissions(It.IsAny <string>())).ReturnsAsync(dbUp);
sp.Setup(s => s.GetService(typeof(IPermissionManager))).Returns(pm.Object);
var data = new TestClass
{
Value = 123
};
var ed = new DomainEvent
{
Data = data,
PerformedByUserId = userId,
WorkContext = new WorkContext {
CurrentEntityConfigRecord = ecr
},
};
var ph = new DefaultPermissionsEventsHandler(sp.Object);
ph.PermissionCreatedHandler(ed);
Thread.Sleep(250);
pm.Verify(p => p.UpdateUserPermissions(It.Is <UserPermissions>(
up => up.UserId == userId &&
up.EntityPermissions.Count() == 2 &&
up.EntityPermissions.ElementAt(1).PermissionKeys.Contains(expPr.ReadKey) &&
up.EntityPermissions.ElementAt(1).PermissionKeys.Contains(expPr.UpdateKey) &&
up.EntityPermissions.ElementAt(1).PermissionKeys.Contains(expPr.DeleteKey))),
Times.Once);
}
public async Task ParseRequestInfoAndMoveToNext()
{
int i = 0,
expI = 15;
string expUserId = "user-id",
route = "/some-resource/part2/",
expRequesteeId = "123",
expPath = $"{route}/__public/{expRequesteeId}",
expMethod = "get";
var ecr = new EntityConfigRecord
{
Name = "nane",
EndpointSettings = new EndpointSettings
{
Route = route,
},
Type = typeof(string),
};
var entityConfigRecords = new[] { ecr };
RequestDelegate reqDel = hc =>
{
i = expI;
return(Task.CompletedTask);
};
var logger = new Mock <ILogger <WorkContextMiddleware> >();
var user = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, expUserId) }));
var ctx = new Mock <HttpContext>();
var req = new Mock <HttpRequest>();
req.Setup(r => r.Path).Returns(new PathString(expPath));
req.Setup(r => r.Method).Returns(expMethod);
req.SetupGet(r => r.Headers).Returns(new HeaderDictionary());
var response = new Mock <HttpResponse>();
ctx.Setup(h => h.User).Returns(user);
ctx.Setup(h => h.Request).Returns(req.Object);
ctx.Setup(h => h.Response).Returns(response.Object);
var wc = new WorkContext();
var wcm = new WorkContextMiddleware(reqDel, entityConfigRecords, logger.Object);
await wcm.InvokeAsync(ctx.Object, wc);
i.ShouldBe(expI);
wc.CurrentEntityConfigRecord.ShouldBe(ecr);
wc.RequestInfo.Path.ShouldBe(expPath);
wc.RequestInfo.Method.ShouldBe(expMethod);
wc.RequestInfo.RequesteeId.ShouldBe(expRequesteeId);
}
public void AllFuncs()
{
string post = "post",
get = "get",
put = "put",
delete = "delete";
var tc = new EntityConfigRecord {
PermissionRecord = new PermissionRecord(post, get, put, delete)
};
PermissionFuncs.GetByHttpMethod(post)(tc).ShouldBe(post);
PermissionFuncs.GetByHttpMethod(get)(tc).ShouldBe(get);
PermissionFuncs.GetByHttpMethod(put)(tc).ShouldBe(put);
PermissionFuncs.GetByHttpMethod(delete)(tc).ShouldBe(delete);
}
public async Task CRUD_ReturnsExpResult(string method, string requesteeId, bool excluded, bool expGrantResult)
{
var ecr = new EntityConfigRecord
{
EntityKey = nameof(TestModel),
Type = typeof(TestModel),
PermissionRecord = new PermissionRecord("create", "read", "update", "delete"),
EndpointSettings = new EndpointSettings
{
PublicGet = true,
},
};
var userPermissions = new UserPermissions
{
EntityPermissions = new[]
{
new EntityPermission
{
Excluded = excluded,
EntityId = "some-entity-id",
EntityKey = nameof(TestModel),
PermissionKeys = new[] { "create", "read", "update", "delete", },
},
},
};
var pm = new Mock <IPermissionManager>();
pm.Setup(pm => pm.GetUserPermissions(It.IsAny <string>())).ReturnsAsync(userPermissions);
var logger = new Mock <ILogger <AnyServicePermissionMiddleware> >();
var mw = new TestAnyServicePermissionware(null, logger.Object);
var wc = new WorkContext
{
CurrentUserId = "userId",
CurrentEntityConfigRecord = ecr,
RequestInfo = new RequestInfo
{
Method = method,
RequesteeId = requesteeId,
},
};
var res = await mw.IsGrantedForTest(wc, pm.Object);
res.ShouldBe(expGrantResult);
}
private static EndpointSettings NormalizeEndpointSettings(EntityConfigRecord ecr, AnyServiceConfig config)
{
var settings = (ecr.EndpointSettings ??= new EndpointSettings());
if (settings.Disabled)
{
return(null);
}
BuildControllerMethodSettings(settings, ecr);
if (!settings.Route.HasValue)
{
var areaPrefix = settings.Area.HasValue() ? $"{settings.Area}/" : "";
settings.Route = new PathString($"/{areaPrefix}{ecr.Type.Name}");
}
var route = settings.Route;
if (route.Value.EndsWith("/"))
{
settings.Route = new PathString(route.Value[0..^ 1]);
public void BuildDisabledMethodMap()
{
var e = new EntityConfigRecord
{
Name = "name",
EndpointSettings = new EndpointSettings
{
GetSettings = new EndpointMethodSettings {
Disabled = true
},
PutSettings = new EndpointMethodSettings {
Disabled = true
},
}
};
var wcmt = new WorkContextMiddleware_ForTests(new[] { e });
wcmt.ActiveMap[$"{e.Name}_post"].ShouldBeFalse();
wcmt.ActiveMap[$"{e.Name}_get"].ShouldBeTrue();
wcmt.ActiveMap[$"{e.Name}_put"].ShouldBeTrue();
wcmt.ActiveMap[$"{e.Name}_delete"].ShouldBeFalse();
}
