public void SilentlyRemoveNonExistentAlias()
{
string id = null;
string dn = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
User e = new User
{
PrimaryEmail = dn,
Password = Guid.NewGuid().ToString(),
Name = new UserName
{
GivenName = "gn",
FamilyName = "sn"
}
};
e = UnitTestControl.TestParameters.UsersService.Add(e);
id = e.Id;
string alias1 = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
string alias2 = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
UnitTestControl.TestParameters.UsersService.AddAlias(id, alias1);
UnitTestControl.TestParameters.UsersService.AddAlias(id, alias2);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = dn;
cs.ObjectType = SchemaConstants.User;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeUpdate("aliases", new List <ValueChange>
{
new ValueChange($"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}", ValueModificationType.Delete)
}));
try
{
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.User], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.UsersService.Get(id);
CollectionAssert.AreEquivalent(new string[] { alias1, alias2 }, e.Aliases);
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.UsersService.Delete(id);
}
}
}
private static CSEntryChangeResult PutCSEntryChangeAdd(CSEntryChange csentry, CSEntryChange deltaCSEntry, MASchemaType maType, SchemaType type, IManagementAgentParameters config)
{
deltaCSEntry.ObjectModificationType = csentry.ObjectModificationType;
IApiInterfaceObject primaryInterface = maType.ApiInterface;
object instance = primaryInterface.CreateInstance(csentry);
foreach (AttributeChange change in primaryInterface.ApplyChanges(csentry, type, ref instance))
{
deltaCSEntry.AttributeChanges.Add(change);
}
deltaCSEntry.DN = primaryInterface.GetDNValue(instance);
List <AttributeChange> anchorChanges = new List <AttributeChange>();
foreach (string anchorAttributeName in maType.AnchorAttributeNames)
{
object value = primaryInterface.GetAnchorValue(anchorAttributeName, instance);
deltaCSEntry.AnchorAttributes.Add(AnchorAttribute.Create(anchorAttributeName, value));
anchorChanges.Add(AttributeChange.CreateAttributeAdd(anchorAttributeName, value));
}
return(CSEntryChangeResult.Create(csentry.Identifier, anchorChanges, MAExportError.Success));
}
public void UpdateDescription()
{
Group e = null;
try
{
e = UnitTestControl.CreateGroup();
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeDelete("description"));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail($"{result.ErrorName}\n{result.ErrorDetail}");
}
e = UnitTestControl.TestParameters.GroupsService.Get(e.Id);
Assert.AreEqual(cs.DN, e.Email);
Assert.AreEqual(true, e.AdminCreated);
Assert.AreEqual(string.Empty, e.Description);
}
finally
{
UnitTestControl.Cleanup(e);
}
}
public object GetObjectToSerialize(object obj, Type targetType)
{
ValueChange valueChange = obj as ValueChange;
if (valueChange != null)
{
return(new ValueChangeSerializable(valueChange));
}
AttributeChange attributeChange = obj as AttributeChange;
if (attributeChange != null)
{
return(new AttributeChangeSerializable(attributeChange));
}
CSEntryChange csentry = obj as CSEntryChange;
if (csentry != null)
{
return(new CSEntryChangeSerializable(csentry));
}
CSEntryChangeResult csentryresult = obj as CSEntryChangeResult;
if (csentryresult != null)
{
return(new CSEntryChangeResultSerializable(csentryresult));
}
AnchorAttribute anchor = obj as AnchorAttribute;
if (anchor != null)
{
return(new AnchorAttributeSerializable(anchor));
}
SchemaAttribute schemaAttribute = obj as SchemaAttribute;
if (schemaAttribute != null)
{
return(new SchemaAttributeSerializable(schemaAttribute));
}
SchemaType schemaType = obj as SchemaType;
if (schemaType != null)
{
return(new SchemaTypeSerializable(schemaType));
}
Schema schema = obj as Schema;
if (schema != null)
{
return(new SchemaSerializable(schema));
}
return(obj);
}
private async Task CreateChannelCSEntryChanges(string groupid, SchemaType schemaType)
{
if (!this.context.Types.Types.Contains("channel"))
{
return;
}
var channels = await GraphHelperTeams.GetChannels(this.betaClient, groupid, this.token);
foreach (var channel in channels)
{
var members = await GraphHelperTeams.GetChannelMembers(this.betaClient, groupid, channel.Id, this.token);
CSEntryChange c = CSEntryChange.Create();
c.ObjectType = "channel";
c.ObjectModificationType = ObjectModificationType.Add;
c.AnchorAttributes.Add(AnchorAttribute.Create("id", channel.Id));
c.DN = channel.Id;
c.AttributeChanges.Add(AttributeChange.CreateAttributeAdd("displayName", channel.DisplayName));
if (!string.IsNullOrWhiteSpace(channel.Description))
{
c.AttributeChanges.Add(AttributeChange.CreateAttributeAdd("description", channel.Description));
}
if (members.Count > 0)
{
c.AttributeChanges.Add(AttributeChange.CreateAttributeAdd("member", members.Select(t => t.Id).ToList <object>()));
}
this.context.ImportItems.Add(c, this.token);
}
}
public async Task ReplaceTeamOwners()
{
List <string> members = UnitTestControl.Users.Take(1).Select(t => t.Id).ToList();
List <string> owners = UnitTestControl.Users.GetRange(1, 100).Select(t => t.Id).ToList();
string teamid = await GroupTests.CreateAndValidateTeam("mytestteam", members, owners);
var cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Update;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", teamid));
var ownersToDelete = owners;
var ownersToAdd = UnitTestControl.Users.GetRange(101, 100).Select(t => t.Id).ToList();
cs.CreateAttributeUpdate("owner", ownersToAdd.ToList <object>(), ownersToDelete.ToList <object>());
var teamResult = await teamExportProvider.PutCSEntryChangeAsync(cs);
Assert.IsTrue(teamResult.ErrorCode == MAExportError.Success);
var actual = (await GraphHelperGroups.GetGroupOwners(UnitTestControl.Client, teamid, CancellationToken.None)).Select(t => t.Id).ToList();
CollectionAssert.AreEquivalent(ownersToAdd, actual);
}
public async Task DeleteTeam()
{
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Add;
cs.CreateAttributeAdd("displayName", "mytestteam");
cs.CreateAttributeAdd("owner", UnitTestControl.Users.GetRange(0, 1).Select(t => t.Id).ToList <object>());
string teamid = await TeamTests.SubmitCSEntryChange(cs);
cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Delete;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", teamid));
await TeamTests.SubmitCSEntryChange(cs);
try
{
var team = await GraphHelperGroups.GetGroup(UnitTestControl.Client, teamid, CancellationToken.None);
Assert.Fail("The team was not deleted");
}
catch (ServiceException ex)
{
if (ex.StatusCode != System.Net.HttpStatusCode.NotFound)
{
Assert.Fail("The team was not deleted");
}
}
}
private static void XmlReadAnchorAttributeNode(XElement element, CSEntryChange csentry)
{
string name = null;
string value = null;
foreach (var child in element.Elements())
{
if (child.Name.LocalName == "name")
{
name = (string)child;
}
else if (child.Name.LocalName == "value")
{
value = (string)child;
}
}
if (string.IsNullOrWhiteSpace(name) && string.IsNullOrWhiteSpace(value))
{
return;
}
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(value))
{
throw new ArgumentException("The name and value elements of an <anchor-attribute> must not be null");
}
AnchorAttribute anchor = AnchorAttribute.Create(name, value);
csentry.AnchorAttributes.Add(anchor);
}
public void Delete()
{
string id = null;
User owner = null;
try
{
owner = UserTests.CreateUser();
Course e = new Course
{
Name = "name",
OwnerId = owner.Id
};
e = UnitTestControl.TestParameters.ClassroomService.Add(e);
id = e.Id;
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Delete;
cs.DN = id;
cs.ObjectType = SchemaConstants.Course;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
CSEntryChangeResult result = ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Course], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
try
{
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.ClassroomService.GetCourse(id);
Assert.Fail("The object did not get deleted");
}
catch (GoogleApiException ex)
{
if (ex.HttpStatusCode == HttpStatusCode.NotFound)
{
id = null;
}
else
{
throw;
}
}
}
finally
{
UnitTestControl.Cleanup(owner);
if (id != null)
{
UnitTestControl.TestParameters.ClassroomService.Delete(id);
}
}
}
public void Delete()
{
string id = null;
try
{
string dn = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
User e = new User
{
PrimaryEmail = dn,
Password = Guid.NewGuid().ToString(),
Name =
{
GivenName = "test",
FamilyName = "test"
}
};
e = UnitTestControl.TestParameters.UsersService.Add(e);
id = e.Id;
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Delete;
cs.DN = dn;
cs.ObjectType = SchemaConstants.User;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
CSEntryChangeResult result = ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.User], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
try
{
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.UsersService.Get(id);
Assert.Fail("The object did not get deleted");
}
catch (GoogleApiException ex)
{
if (ex.HttpStatusCode == HttpStatusCode.NotFound)
{
id = null;
}
else
{
throw;
}
}
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.UsersService.Delete(id);
}
}
}
public void UpdateBuildingClearValues()
{
Building building = new Building();
building.BuildingId = "test-building";
building.BuildingName = "My building";
building.Description = "some description";
building.FloorNames = new List <string>()
{
"B1", "B2", "G"
};
building.Coordinates = new BuildingCoordinates()
{
Latitude = -66, Longitude = 44
};
UnitTestControl.TestParameters.ResourcesService.AddBuilding(UnitTestControl.TestParameters.CustomerID, building);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = $"{building.BuildingId}{ApiInterfaceBuilding.DNSuffix}";
cs.ObjectType = SchemaConstants.Building;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", building.BuildingId));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeDelete("description"));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeDelete("coordinates_latitude"));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeDelete("coordinates_longitude"));
string id = building.BuildingId;
try
{
CSEntryChangeResult result = ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Building], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
Building c = UnitTestControl.TestParameters.ResourcesService.GetBuilding(UnitTestControl.TestParameters.CustomerID, id);
Assert.AreEqual("test-building", c.BuildingId);
Assert.IsTrue(string.IsNullOrEmpty(c.Description));
Assert.IsNull(c.Coordinates?.Longitude);
Assert.IsNull(c.Coordinates?.Latitude);
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.ResourcesService.DeleteBuilding(UnitTestControl.TestParameters.CustomerID, id);
}
}
}
public void Rename()
{
string id = null;
try
{
string dn = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
User e = new User
{
PrimaryEmail = dn,
Password = Guid.NewGuid().ToString(),
Name =
{
GivenName = "test",
FamilyName = "test"
}
};
e = UnitTestControl.TestParameters.UsersService.Add(e);
id = e.Id;
System.Threading.Thread.Sleep(2000);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = dn;
cs.ObjectType = SchemaConstants.User;
string newDN = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
cs.AttributeChanges.Add(AttributeChange.CreateAttributeUpdate("DN", new List <ValueChange>()
{
ValueChange.CreateValueAdd(newDN), ValueChange.CreateValueDelete(dn)
}));
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.User], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
System.Threading.Thread.Sleep(2000);
e = UnitTestControl.TestParameters.UsersService.Get(id);
Assert.AreEqual(newDN, e.PrimaryEmail);
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.UsersService.Delete(id);
}
}
}
public void ContactDelete()
{
string id = null;
try
{
string dn = Guid.NewGuid().ToString();
ContactEntry e = new ContactEntry
{
BillingInformation = "test"
};
e.ExtendedProperties.Add(new ExtendedProperty(dn, ApiInterfaceContact.DNAttributeName));
e = UnitTestControl.TestParameters.ContactsService.Add(e, UnitTestControl.TestParameters.Domain);
id = e.SelfUri.Content;
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Delete;
cs.DN = dn;
cs.ObjectType = SchemaConstants.Contact;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
CSEntryChangeResult result = ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Contact], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
try
{
System.Threading.Thread.Sleep(5000);
e = UnitTestControl.TestParameters.ContactsService.GetContact(id);
Assert.Fail("The object did not get deleted");
}
catch (GDataRequestException ex)
{
if (((HttpWebResponse)ex.Response).StatusCode == HttpStatusCode.NotFound)
{
id = null;
}
else
{
throw;
}
}
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.ContactsService.Delete(id);
}
}
}
public void ReplaceMembers()
{
Group e = null;
Group member1 = null;
Group member2 = null;
Group member3 = null;
Group member4 = null;
try
{
e = UnitTestControl.CreateGroup();
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
member1 = UnitTestControl.CreateGroup();
member2 = UnitTestControl.CreateGroup();
member3 = UnitTestControl.CreateGroup();
member4 = UnitTestControl.CreateGroup();
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, new Member()
{
Email = member1.Email
});
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, new Member()
{
Email = member2.Email
});
Thread.Sleep(1000);
cs.AttributeChanges.Add(AttributeChange.CreateAttributeReplace("member", new List <object>()
{
member3.Email, member4.Email
}));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
Thread.Sleep(10000);
CollectionAssert.AreEquivalent(new string[] { member3.Email, member4.Email }, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).Members.ToArray());
}
finally
{
UnitTestControl.Cleanup(e, member1, member2, member3, member4);
}
}
private static CSEntryChange CreateCSEntryUpdate(Group e)
{
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
return(cs);
}
public void RemoveMembers()
{
Group e = null;
Group member1 = null;
Group member2 = null;
try
{
e = UnitTestControl.CreateGroup();
member1 = UnitTestControl.CreateGroup();
member2 = UnitTestControl.CreateGroup();
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, new Member()
{
Email = member1.Email
});
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, new Member()
{
Email = member2.Email
});
Thread.Sleep(1000);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeDelete("member"));
CSEntryChangeResult result = ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
Thread.Sleep(1000);
Assert.AreEqual(0, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).Members.Count);
Assert.AreEqual(0, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).ExternalMembers.Count);
Assert.AreEqual(0, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).Managers.Count);
Assert.AreEqual(0, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).ExternalManagers.Count);
Assert.AreEqual(0, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).Owners.Count);
Assert.AreEqual(0, UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN).ExternalOwners.Count);
}
finally
{
UnitTestControl.Cleanup(e, member1, member2);
}
}
public void ContactRename()
{
string id = null;
try
{
string dn = Guid.NewGuid().ToString();
ContactEntry e = new ContactEntry();
e.Emails.Add(new EMail()
{
Address = "*****@*****.**", Label = "work"
});
e.ExtendedProperties.Add(new ExtendedProperty(dn, ApiInterfaceContact.DNAttributeName));
e = UnitTestControl.TestParameters.ContactsService.Add(e, UnitTestControl.TestParameters.Domain);
id = e.SelfUri.Content;
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = dn;
cs.ObjectType = SchemaConstants.Contact;
string newDN = Guid.NewGuid().ToString();
cs.AttributeChanges.Add(AttributeChange.CreateAttributeUpdate("DN", new List <ValueChange>()
{
ValueChange.CreateValueAdd(newDN), ValueChange.CreateValueDelete(dn)
}));
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
CSEntryChangeResult result = ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Contact], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
System.Threading.Thread.Sleep(5000);
e = UnitTestControl.TestParameters.ContactsService.GetContact(id);
Assert.AreEqual(newDN, e.ExtendedProperties.Single(t => t.Name == ApiInterfaceContact.DNAttributeName).Value);
var x = CSEntryChangeQueue.Take();
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.ContactsService.Delete(id);
}
}
}
public void DowngradeManagersToMembers()
{
Group e = null;
User member1 = null;
User member2 = null;
User member3 = null;
User member4 = null;
try
{
e = UnitTestControl.CreateGroup();
member1 = UserTests.CreateUser();
member2 = UserTests.CreateUser();
member3 = UserTests.CreateUser();
member4 = UserTests.CreateUser();
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, member1.PrimaryEmail, "MANAGER");
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, member2.PrimaryEmail, "MANAGER");
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, member3.PrimaryEmail, "MEMBER");
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, member4.PrimaryEmail, "MEMBER");
Thread.Sleep(1000);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Email));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeDelete("manager"));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
Thread.Sleep(1000);
GroupMembership membership = UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN);
Assert.AreEqual(0, membership.ExternalManagers.Count);
Assert.AreEqual(0, membership.Managers.Count);
Assert.AreEqual(0, membership.ExternalMembers.Count);
CollectionAssert.AreEquivalent(new string[] { member1.PrimaryEmail, member2.PrimaryEmail, member3.PrimaryEmail, member4.PrimaryEmail }, membership.Members.ToArray());
}
finally
{
UnitTestControl.Cleanup(e, member1, member2, member3, member4);
}
}
/// <summary>
/// Gets the specified anchor attribute
/// </summary>
/// <param name="csentry">The CSEntryChange to get the anchor from</param>
/// <param name="anchorName">The name of the anchor attribute</param>
/// <returns>The anchor attribute, or null if the anchor was not present</returns>
public static AnchorAttribute GetAnchorAttribute(this CSEntryChange csentry, string anchorName)
{
AnchorAttribute anchor = csentry.AnchorAttributes.FirstOrDefault(t => t.Name == anchorName);
if (anchor != null)
{
return(anchor);
}
else
{
return(null);
}
}
/// <summary>
/// Gets the value of the specified anchor attribute if it exists, or the default value of the type if it doesn't
/// </summary>
/// <typeparam name="T">The data type of the anchor attribute</typeparam>
/// <param name="csentry">The CSEntryChange to get the anchor value from</param>
/// <param name="anchorName">The name of the anchor attribute</param>
/// <returns>The value of the anchor attribute, or default(T) if the anchor was not present</returns>
public static T GetAnchorValueOrDefault <T>(this CSEntryChange csentry, string anchorName)
{
AnchorAttribute anchor = csentry.AnchorAttributes.FirstOrDefault(t => t.Name == anchorName);
if (anchor != null)
{
return((T)anchor.Value);
}
else
{
return(default(T));
}
}
public void MakeAdmin()
{
string id = null;
string dn = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
User e = new User
{
PrimaryEmail = dn,
Password = Guid.NewGuid().ToString(),
Name = new UserName
{
GivenName = "gn",
FamilyName = "sn"
}
};
e = UnitTestControl.TestParameters.UsersService.Add(e);
id = e.Id;
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = dn;
cs.ObjectType = SchemaConstants.User;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeAdd("isAdmin", true));
try
{
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.User], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.UsersService.Get(id);
Assert.AreEqual(true, e.IsAdmin);
}
finally
{
if (id != null)
{
UnitTestControl.TestParameters.UsersService.Delete(id);
}
}
}
public void Update()
{
User owner = null;
string id = null;
try
{
owner = UserTests.CreateUser();
Course e = new Course
{
Name = "name",
OwnerId = owner.Id
};
e = UnitTestControl.TestParameters.ClassroomService.Add(e);
id = e.Id;
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = id;
cs.ObjectType = SchemaConstants.Course;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeAdd("name", "name2"));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Course], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.ClassroomService.GetCourse(id);
Assert.AreEqual("name2", e.Name);
}
finally
{
UnitTestControl.Cleanup(owner);
if (id != null)
{
UnitTestControl.TestParameters.ClassroomService.Delete(id);
}
}
}
public void DowngradeOwnerToManager()
{
Group e = null;
try
{
e = UnitTestControl.CreateGroup();
string member2 = "*****@*****.**";
Thread.Sleep(1000);
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, member2, "OWNER");
Thread.Sleep(1000);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeUpdate("externalOwner", new List <ValueChange>()
{
new ValueChange(member2, ValueModificationType.Delete)
}));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
Thread.Sleep(1000);
GroupMembership membership = UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(cs.DN);
Assert.AreEqual(0, membership.ExternalOwners.Count);
Assert.AreEqual(0, membership.Owners.Count);
Assert.AreEqual(0, membership.Managers.Count);
Assert.AreEqual(0, membership.Members.Count);
CollectionAssert.AreEquivalent(new string[] { member2 }, membership.ExternalManagers.ToArray());
}
finally
{
UnitTestControl.Cleanup(e);
}
}
public void ReplaceAliases()
{
Group e = null;
try
{
e = UnitTestControl.CreateGroup();
string alias1 = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
string alias2 = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
string alias3 = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
string alias4 = $"{Guid.NewGuid()}@{UnitTestControl.TestParameters.Domain}";
UnitTestControl.TestParameters.GroupsService.AddAlias(e.Id, alias1);
UnitTestControl.TestParameters.GroupsService.AddAlias(e.Id, alias2);
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Update;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
cs.AttributeChanges.Add(AttributeChange.CreateAttributeReplace("aliases", new List <object>
{
alias3, alias4
}));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.GroupsService.Get(e.Id);
CollectionAssert.AreEquivalent(new string[] { alias3, alias4 }, e.Aliases.ToArray());
}
finally
{
UnitTestControl.Cleanup(e);
}
}
public async Task UpdateGroupAttributes()
{
string displayName1 = "displayName 1";
string description1 = "description 1";
string mailNickname1 = $"ut-{Guid.NewGuid()}";
string displayName2 = "displayName 2";
string description2 = "description 2";
string mailNickname2 = $"ut-{Guid.NewGuid()}";
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Add;
cs.CreateAttributeAdd("displayName", displayName1);
cs.CreateAttributeAdd("description", description1);
cs.CreateAttributeAdd("mailNickname", mailNickname1);
cs.CreateAttributeAdd("owner", UnitTestControl.Users.GetRange(0, 1).Select(t => t.Id).ToList <object>());
string teamid = await SubmitCSEntryChange(cs);
await Task.Delay(TimeSpan.FromSeconds(30));
var team = await GraphHelperGroups.GetGroup(UnitTestControl.Client, teamid, CancellationToken.None);
Assert.AreEqual(displayName1, team.DisplayName);
Assert.AreEqual(description1, team.Description);
Assert.AreEqual(mailNickname1, team.MailNickname);
cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", teamid));
cs.ObjectModificationType = ObjectModificationType.Update;
cs.CreateAttributeReplace("displayName", displayName2);
cs.CreateAttributeReplace("description", description2);
cs.CreateAttributeReplace("mailNickname", mailNickname2);
await SubmitCSEntryChange(cs);
team = await GraphHelperGroups.GetGroup(UnitTestControl.Client, teamid, CancellationToken.None);
Assert.AreEqual(displayName2, team.DisplayName);
Assert.AreEqual(description2, team.Description);
Assert.AreEqual(mailNickname2, team.MailNickname);
}
public void Delete()
{
Group e = null;
try
{
e = UnitTestControl.CreateGroup();
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectModificationType = ObjectModificationType.Delete;
cs.DN = e.Email;
cs.ObjectType = SchemaConstants.Group;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", e.Id));
CSEntryChangeResult result =
ExportProcessor.PutCSEntryChange(cs, UnitTestControl.Schema.GetSchema().Types[SchemaConstants.Group], UnitTestControl.TestParameters);
if (result.ErrorCode != MAExportError.Success)
{
Assert.Fail(result.ErrorName);
}
try
{
System.Threading.Thread.Sleep(UnitTestControl.PostGoogleOperationSleepInterval);
e = UnitTestControl.TestParameters.GroupsService.Get(e.Id);
Assert.Fail("The object did not get deleted");
}
catch (GoogleApiException ex)
{
if (ex.HttpStatusCode == HttpStatusCode.NotFound)
{
e = null;
}
else
{
throw;
}
}
}
finally
{
UnitTestControl.Cleanup(e);
}
}
public async Task ThrowOnIsArchivedDelete()
{
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Update;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", "1234"));
cs.CreateAttributeDelete("isArchived");
try
{
await teamExportProvider.PutCSEntryChangeAsync(cs);
Assert.Fail("The expected exception was not thrown");
}
catch (UnsupportedBooleanAttributeDeleteException)
{
}
}
public static CSEntryChangeResult PutCSEntryChangeObject(CSEntryChange csentry, SchemaType type, IManagementAgentParameters config)
{
MASchemaType maType = ManagementAgent.Schema[type.Name];
CSEntryChangeDetached deltaCSEntry = new CSEntryChangeDetached(Guid.NewGuid(), ObjectModificationType.Unconfigured, MAImportError.Success, null);
foreach (var anchorAttributeName in maType.AnchorAttributeNames)
{
AnchorAttribute anchor = csentry.GetAnchorAttribute(anchorAttributeName);
if (anchor != null)
{
deltaCSEntry.AnchorAttributes.Add(anchor);
}
}
deltaCSEntry.ObjectType = csentry.ObjectType;
try
{
switch (csentry.ObjectModificationType)
{
case ObjectModificationType.Add:
return(ExportProcessor.PutCSEntryChangeAdd(csentry, deltaCSEntry, maType, type, config));
case ObjectModificationType.Delete:
return(ExportProcessor.PutCSEntryChangeDelete(csentry, deltaCSEntry, maType));
case ObjectModificationType.Update:
return(ExportProcessor.PutCSEntryChangeUpdate(csentry, deltaCSEntry, maType, type, config));
default:
case ObjectModificationType.None:
case ObjectModificationType.Replace:
case ObjectModificationType.Unconfigured:
throw new InvalidOperationException($"Unknown or unsupported modification type: {csentry.ObjectModificationType} on object {csentry.DN}");
}
}
finally
{
CSEntryChangeQueue.Add(deltaCSEntry);
}
}
public async Task ThrowOnTemplateDelete()
{
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Update;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", "1234"));
cs.CreateAttributeDelete("template");
try
{
await teamExportProvider.PutCSEntryChangeAsync(cs);
Assert.Fail("The expected exception was not thrown");
}
catch (InitialFlowAttributeModificationException)
{
}
}
public async Task ArchiveTeam()
{
CSEntryChange cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Add;
cs.CreateAttributeAdd("displayName", "mytestteam");
cs.CreateAttributeAdd("owner", UnitTestControl.Users.GetRange(0, 1).Select(t => t.Id).ToList <object>());
string teamid = await TeamTests.SubmitCSEntryChange(cs);
cs = CSEntryChange.Create();
cs.ObjectType = "team";
cs.ObjectModificationType = ObjectModificationType.Update;
cs.AnchorAttributes.Add(AnchorAttribute.Create("id", teamid));
cs.CreateAttributeAdd("isArchived", true);
await TeamTests.SubmitCSEntryChange(cs);
var team = await GraphHelperTeams.GetTeam(UnitTestControl.BetaClient, teamid, CancellationToken.None);
Assert.IsTrue(team.IsArchived ?? false);
}
