private bool IsUpnValid(string upn)
{
GrouperDocument document = TestHelpers.MakeDocument(new
{
Members = new[]
{
new
{
Source = GroupMemberSources.Static,
Rules = new []
{
new
{
Name = "Upn",
Value = upn
}
}
}
}
});
UpnValidator upnValidator = new UpnValidator();
List <ValidationError> validationErrors = new List <ValidationError>();
upnValidator.Validate(document, document.Members[0], validationErrors);
return(validationErrors.Count == 0);
}
public void TestValidateWithBrokenDocument()
{
GrouperDocument document = TestHelpers.MakeDocument(new
{
GroupId = groupId,
Members = new []
{
new
{
Source = GroupMemberSources.OnPremAdGroup,
Rules = new[]
{
new
{
Name = "Group",
Value = groupId
}
}
}
}
});
ICustomValidator validator = new OnPremAdValidator();
List <ValidationError> errors = new List <ValidationError>();
validator.Validate(document, document.Members[0], errors);
Assert.True(errors.Count > 0);
}
public static async Task <GrouperDocument> MakeDocumentAsync(HttpRequest request)
{
using StreamReader stream = new StreamReader(request.Body);
string document = await stream.ReadToEndAsync();
return(GrouperDocument.FromJson(document));
}
public void TestEquals()
{
GrouperDocument document1 = TestHelpers.MakeDocument();
GrouperDocument document2 = TestHelpers.MakeDocument();
Assert.True(document1.Equals(document2));
}
private async Task <IList <GrouperDocumentEntry> > InternalGetDocumentEntriesAsync(string storedProcedure, IDictionary <string, object> parameters)
{
var result = new List <GrouperDocumentEntry>();
using (var conn = new SqlConnection(_connectionString))
{
await conn.OpenAsync();
using (var cmd = new SqlCommand())
{
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = storedProcedure;
cmd.AddParameters(parameters);
using (var reader = await cmd.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
result.Add(new GrouperDocumentEntry(
document: GrouperDocument.FromJson(reader.GetString(5)),
revision: reader.GetInt32(0),
revisionCreated: reader.GetDateTime(1),
isPublished: reader.GetBoolean(2),
isDeleted: reader.GetBoolean(3),
tags: (reader.IsDBNull(4) ? Array.Empty <string>() : reader.GetString(4).Split(','))
));
}
}
}
}
return(result);
}
public void TestSerializationOfGroupStore()
{
GrouperDocument document = TestHelpers.MakeDocument();
string serializedDocument = document.ToJson();
dynamic obj = JObject.Parse(serializedDocument);
Assert.Equal(TestHelpers.DefaultGroupStore.ToString(), (string)obj.store);
}
private IGroupOwnerSource GetOwnerSource(GrouperDocument document)
{
if (_ownerSources.TryGetValue(document.Store, out IGroupOwnerSource source))
{
return(source);
}
return(null);
}
public void TestNotEquals()
{
Guid guid = Guid.Parse("191de1de-df8c-4f1d-b07c-aec81fff52c1");
GrouperDocument document1 = TestHelpers.MakeDocument();
GrouperDocument document2 = TestHelpers.MakeDocument(new { Id = guid });
Assert.False(document1.Equals(document2));
}
private IGroupStore GetGroupStore(GrouperDocument document)
{
if (_groupStores.TryGetValue(document.Store, out IGroupStore store))
{
return(store);
}
throw new InvalidOperationException($"There is no group store added for {document.Store}");
}
private async Task <GroupMemberCollection> GetCurrentMembersAsync(GrouperDocument document)
{
var memberCollection = new GroupMemberCollection();
IGroupStore store = GetGroupStore(document);
await store.GetGroupMembersAsync(memberCollection, document.GroupId);
return(memberCollection);
}
public void TestSerializationOfGroupOwnerAction()
{
GrouperDocument document = TestHelpers.MakeDocument(new { Store = GroupStores.AzureAd, Owner = TestHelpers.DefaultOwnerAction });
string serializedDocument = document.ToJson();
dynamic obj = JObject.Parse(serializedDocument);
Assert.Equal(TestHelpers.DefaultOwnerAction.ToString(), (string)obj.owner);
}
public async Task StoreDocumentAsync(GrouperDocument document)
{
await InternalExecuteStoredProcedureAsync("dbo.store_document",
new Dictionary <string, object>() {
{ "author", _author },
{ "json", document.ToJson(Newtonsoft.Json.Formatting.None) }
}
);
}
public void TestCloneWithNewName()
{
GrouperDocument document = TestHelpers.MakeDocument();
string newGroupName = "New Group Name";
GrouperDocument newDocument = document.CloneWithNewGroupName(newGroupName);
Assert.Equal(TestHelpers.DefaultDocumentId, newDocument.Id);
Assert.Equal(newGroupName, newDocument.GroupName);
}
public async Task <IActionResult> ValidateDocument(string lang)
{
_stringResourceHelper.SetLanguage(lang);
using StreamReader stream = new StreamReader(Request.Body);
string document = await stream.ReadToEndAsync();
List <ValidationError> errors = new List <ValidationError>();
GrouperDocument.FromJson(document, errors);
return(Ok(errors));
}
public void TestConstructionWithDocument()
{
GrouperDocument document = TestHelpers.MakeDocument();
GroupMember member = new GroupMember(Guid.Empty, "Member", GroupMemberTypes.OnPremAd);
GroupMemberOperations operation = GroupMemberOperations.Add;
GroupMemberOperation memberOperation = new GroupMemberOperation(document, member, operation);
Assert.Equal(document.GroupId, memberOperation.GroupId);
Assert.Equal(document.GroupName, memberOperation.GroupName);
Assert.Equal(member, memberOperation.Member);
Assert.Equal(operation, memberOperation.Operation);
}
public void TestConstructionWithDocument()
{
GrouperDocument document = TestHelpers.MakeDocument();
EventLogItem logItem = new EventLogItem(document, message, logLevel);
Assert.Equal(TestHelpers.DefaultDocumentId, logItem.DocumentId);
Assert.Equal(TestHelpers.DefaultGroupName, logItem.GroupDisplayName);
Assert.Equal(TestHelpers.DefaultGroupId, logItem.GroupId);
Assert.Equal(TestHelpers.DefaultGroupStore, logItem.GroupStore);
Assert.Equal(message, logItem.Message);
Assert.Equal(logLevel, logItem.LogLevel);
}
public async Task <GroupMemberDiff> GetMemberDiffAsync(GrouperDocument document, bool includeUnchanged = false)
{
if (document is null)
{
throw new ArgumentNullException(nameof(document));
}
var currentMembers = await GetCurrentMembersAsync(document);
var targetMembers = await GetTargetMembersAsync(document);
IGroupOwnerSource ownerSource = GetOwnerSource(document);
if (ownerSource != null)
{
if (document.Owner != GroupOwnerActions.MatchSource)
{
var owners = new GroupMemberCollection();
await ownerSource.GetGroupOwnersAsync(owners, document.GroupId);
if (document.Owner == GroupOwnerActions.KeepExisting)
{
owners.IntersectWith(currentMembers);
}
targetMembers.Add(owners);
}
}
if (!currentMembers.ContainsMatchingMemberType(targetMembers))
{
throw new InvalidOperationException("Member types does not match");
}
GroupMemberCollection unchangedMembers = new GroupMemberCollection();
if (includeUnchanged)
{
unchangedMembers = currentMembers.Clone();
unchangedMembers.IntersectWith(targetMembers);
}
int currentCount = currentMembers.Count;
currentMembers.FilterUniqueMember(targetMembers);
double changeRatio;
if (currentCount == 0)
{
changeRatio = targetMembers.Count == 0 ? 1.0 : targetMembers.Count;
}
else
{
changeRatio = (currentCount - currentMembers.Count + targetMembers.Count) / (double)currentCount;
}
return(new GroupMemberDiff(document, targetMembers, currentMembers, unchangedMembers, changeRatio));
}
private void WriteToLogDb(GrouperDocument document, string message, LogLevels logLevel)
{
EventLogItem logItem = new EventLogItem(document, message, logLevel);
if (Environment.UserInteractive)
{
Console.WriteLine(logItem.ToString());
}
else
{
_logDb.StoreEventLogItemAsync(logItem).GetAwaiter().GetResult();
}
}
private async Task <GroupMemberCollection> GetTargetMembersAsync(GrouperDocument document)
{
var include = new GroupMemberCollection();
var exclude = new GroupMemberCollection();
foreach (GrouperDocumentMember member in document.Members)
{
var memberCollection = member.Action == GroupMemberActions.Exclude ? exclude : include;
IMemberSource source = GetMemberSource(member);
await source.GetMembersFromSourceAsync(memberCollection, member);
}
include.ExceptWith(exclude);
return(include);
}
public void TestConstructionWithDocument()
{
DateTime now = DateTime.Now;
GrouperDocument document = TestHelpers.MakeDocument();
OperationalLogItem logItem = new OperationalLogItem(document, operation,
new GroupMember(targetId, targetName, GroupMemberTypes.OnPremAd));
Assert.True(logItem.LogTime >= now);
Assert.Equal(TestHelpers.DefaultDocumentId, logItem.DocumentId);
Assert.Equal(TestHelpers.DefaultGroupId, logItem.GroupId);
Assert.Equal(TestHelpers.DefaultGroupName, logItem.GroupDisplayName);
Assert.Equal(TestHelpers.DefaultGroupStore, logItem.GroupStore);
Assert.Equal(operation, logItem.Operation);
Assert.Equal(targetId, logItem.TargetId);
Assert.Equal(targetName, logItem.TargetDisplayName);
}
private async Task <GroupMemberCollection> GetTargetMembersAsync(GrouperDocument document, GroupMemberCollection currentMembers)
{
var include = new GroupMemberCollection();
var exclude = new GroupMemberCollection();
if (!(document.Members.Any(m => m.Action == GroupMemberActions.Include)))
{
include.Add(currentMembers);
}
foreach (GrouperDocumentMember member in document.Members)
{
var memberCollection = member.Action == GroupMemberActions.Exclude ? exclude : include;
IMemberSource source = GetMemberSource(member);
await source.GetMembersFromSourceAsync(memberCollection, member, document.MemberType);
}
include.ExceptWith(exclude);
return(include);
}
public async Task <IActionResult> InvokeGrouper(bool ignoreChangelimit)
{
GrouperDocument document = await Helper.MakeDocumentAsync(Request);
Grouper grouper = GetGrouperBackend();
GroupMemberDiff diff = await grouper.GetMemberDiffAsync(document);
// await grouper.UpdateGroupAsync(diff, ignoreChangelimit);
var changes = new List <OperationalLogItem>();
foreach (GroupMember member in diff.Add)
{
changes.Add(new OperationalLogItem(document, GroupMemberOperations.Add, member));
}
foreach (GroupMember member in diff.Remove)
{
changes.Add(new OperationalLogItem(document, GroupMemberOperations.Remove, member));
}
return(Ok(changes));
}
public void TestSerializedNames()
{
GrouperDocument document = TestHelpers.MakeDocument(
new
{
Store = GroupStores.AzureAd,
Interval = 10
}
);
string json = JsonConvert.SerializeObject(document, Formatting.Indented);
JObject obj = JObject.Parse(json);
Assert.True(obj.ContainsKey("id"));
Assert.True(obj.ContainsKey("interval"));
Assert.True(obj.ContainsKey("groupId"));
Assert.True(obj.ContainsKey("groupName"));
Assert.True(obj.ContainsKey("store"));
Assert.True(obj.ContainsKey("owner"));
Assert.True(obj.ContainsKey("members"));
}
public void TestConstruction()
{
double ratio = 0.5;
GrouperDocument doc = TestHelpers.MakeDocument();
GroupMemberCollection add = new GroupMemberCollection();
add.Add(new GroupMember(Guid.Empty, "M1", GroupMemberTypes.AzureAd));
GroupMemberCollection remove = new GroupMemberCollection();
remove.Add(new GroupMember(Guid.Empty, "M2", GroupMemberTypes.AzureAd));
GroupMemberCollection unchanged = new GroupMemberCollection();
unchanged.Add(new GroupMember(Guid.Empty, "M3", GroupMemberTypes.AzureAd));
GroupMemberDiff diff = new GroupMemberDiff(doc, add, remove, unchanged, ratio);
Assert.NotNull(diff.Add.FirstOrDefault(m => m.DisplayName == "M1"));
Assert.NotNull(diff.Remove.FirstOrDefault(m => m.DisplayName == "M2"));
Assert.NotNull(diff.Unchanged.FirstOrDefault(m => m.DisplayName == "M3"));
Assert.Equal(ratio, diff.ChangeRatio);
Assert.Equal(doc, diff.Document);
}
public void TestGetHashCode()
{
GrouperDocument document = TestHelpers.MakeDocument();
Assert.Equal(TestHelpers.DefaultDocumentId.GetHashCode(), document.GetHashCode());
}
public void TestMembersListShouldBeImmutable()
{
GrouperDocument document = TestHelpers.MakeDocument();
Assert.Throws <NotSupportedException>(() => { document.Members.RemoveAt(0); });
}
public async Task <GroupInfo> GetGroupInfoAsync(GrouperDocument document)
{
IGroupStore store = GetGroupStore(document);
return(await store.GetGroupInfoAsync(document.GroupId));
}
