public void TestGreaterThanFilter()
{
GreaterThanFilter v1 = new GreaterThanFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
GreaterThanFilter v2 = (GreaterThanFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
public void TestAttribute()
{
ConnectorAttribute v1 = ConnectorAttributeBuilder.Build("foo", "val1", "val2");
ConnectorAttribute v2 = (ConnectorAttribute)CloneObject(v1);
Assert.AreEqual(v1, v2);
}
public void TestLessThanOrEqualFilter()
{
LessThanOrEqualFilter v1 = new LessThanOrEqualFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
LessThanOrEqualFilter v2 = (LessThanOrEqualFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
public void TestStartsWithFilter()
{
StartsWithFilter v1 = new StartsWithFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
StartsWithFilter v2 = (StartsWithFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
public void TestDistribution()
{
Filter a =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("a", "a"));
Filter b =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("b", "b"));
Filter c =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("c", "c"));
Filter d =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("d", "d"));
Filter filter =
FilterBuilder.And(
FilterBuilder.Or(a, b),
FilterBuilder.Or(c, d));
String expected = "( & ( | ( CONTAINS a a ) ( CONTAINS b b ) ) ( | ( CONTAINS c c ) ( CONTAINS d d ) ) )";
String actual =
TranslateSingle(new AllFiltersTranslator(), filter);
Assert.AreEqual(expected, actual);
IList <String> results =
new NoOrTranslator().Translate(filter);
Assert.AreEqual(4, results.Count);
Assert.AreEqual("( & ( CONTAINS a a ) ( CONTAINS c c ) )",
results[0]);
Assert.AreEqual("( & ( CONTAINS a a ) ( CONTAINS d d ) )",
results[1]);
Assert.AreEqual("( & ( CONTAINS b b ) ( CONTAINS c c ) )",
results[2]);
Assert.AreEqual("( & ( CONTAINS b b ) ( CONTAINS d d ) )",
results[3]);
}
public void ValidateAddWithNullAttribute()
{
ICollection <ConnectorAttribute> attrs = new HashSet <ConnectorAttribute>();
attrs.Add(ConnectorAttributeBuilder.Build("something"));
UpdateImpl.ValidateInput(ObjectClass.ACCOUNT, new Uid("foo"), attrs, true);
}
public void TestContainsAllValuesFilter()
{
ContainsAllValuesFilter v1 = new ContainsAllValuesFilter(ConnectorAttributeBuilder.Build("foo", "bar", "foo"));
ContainsAllValuesFilter v2 = (ContainsAllValuesFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
public void TestUpdateUnsupportedObjectClass()
{
var updateAttributes = new List <ConnectorAttribute>(1);
updateAttributes.Add(ConnectorAttributeBuilder.Build("email", "*****@*****.**"));
GetFacade().Update(Unknown, new Uid("TESTOK1"), updateAttributes, null);
}
public void TestEqualsFilter()
{
EqualsFilter v1 = new EqualsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
EqualsFilter v2 = (EqualsFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
private void SubmitConnectorObject(String result, ResultsHandler handler)
{
ConnectorObjectBuilder cob = new ConnectorObjectBuilder();
String[] resultSplit = result.Split(new char[] { '$' });
ICollection <ConnectorAttribute> attrs = new List <ConnectorAttribute>();
foreach (String str in resultSplit)
{
ConnectorAttributeBuilder cab = new ConnectorAttributeBuilder();
cab.AddValue(str.Split(new char[] { ':' })[1]);
if (str.StartsWith("Name"))
{
cob.SetName(Name.NAME);
cob.SetUid(str.Split(new char[] { ':' })[1]);
cab.Name = Name.NAME;
}
else
{
cab.Name = str.Split(new char[] { ':' })[0];
}
attrs.Add(cab.Build());
}
cob.AddAttributes(attrs);
handler(cob.Build());
}
public Object Process(Object result)
{
if (result == null)
{
return(true);
}
if (result is ConnectorObject)
{
return(_handler.Handle(result as ConnectorObject));
}
var cobld = new ConnectorObjectBuilder();
var res = result as Hashtable;
foreach (String key in res.Keys)
{
var attrName = key;
var attrValue = res[key];
if ("__UID__".Equals(attrName))
{
if (attrValue == null)
{
throw new ConnectorException("Uid can not be null");
}
cobld.SetUid(attrValue.ToString());
}
else if ("__NAME__".Equals(attrName))
{
if (attrValue == null)
{
throw new ConnectorException("Name can not be null");
}
cobld.SetName(attrValue.ToString());
}
else
{
if (attrValue == null)
{
cobld.AddAttribute(ConnectorAttributeBuilder.Build(attrName));
}
else if (attrValue.GetType() == typeof(Object[]) || attrValue.GetType() == typeof(System.Collections.ICollection))
{
var list = new Collection <object>();
foreach (var val in (ICollection)attrValue)
{
list.Add(FrameworkUtil.IsSupportedAttributeType(val.GetType()) ? val : val.ToString());
}
cobld.AddAttribute(ConnectorAttributeBuilder.Build(attrName, list));
}
else
{
cobld.AddAttribute(ConnectorAttributeBuilder.Build(attrName, attrValue));
}
}
}
cobld.ObjectClass = _objectClass;
return(_handler.Handle(cobld.Build()));
}
/// <summary>
/// Finds the attributes in connector object and rename it according to input array of names, but only
/// if the atribute name is in attributes to get
/// </summary>
/// <param name="cobject">ConnectorObject which attributes should be replaced</param>
/// <param name="map">Replace mapping</param>
/// <returns>ConnectorObject with replaced attributes</returns>
/// <exception cref="ArgumentNullException">If some of the params is null</exception>
internal static ConnectorObject ConvertAdAttributesToExchange(ConnectorObject cobject)
{
Assertions.NullCheck(cobject, "cobject");
var attributes = cobject.GetAttributes();
var builder = new ConnectorObjectBuilder();
bool emailAddressPolicyEnabled = true;
foreach (ConnectorAttribute attribute in attributes)
{
string newName;
if (attribute.Is(ExchangeConnectorAttributes.AttMsExchPoliciesExcludedADName))
{
if (attribute.Value != null && attribute.Value.Contains("{26491cfc-9e50-4857-861b-0cb8df22b5d7}"))
{
emailAddressPolicyEnabled = false;
}
}
else if (attribute.Is(ExchangeConnectorAttributes.AttAddressBookPolicyADName))
{
var newAttribute = ExtractCommonName(attribute, ExchangeConnectorAttributes.AttAddressBookPolicy);
builder.AddAttribute(newAttribute);
builder.AddAttribute(attribute); // keep the original one as well
}
else if (attribute.Is(ExchangeConnectorAttributes.AttOfflineAddressBookADName))
{
var newAttribute = ExtractCommonName(attribute, ExchangeConnectorAttributes.AttOfflineAddressBook);
builder.AddAttribute(newAttribute);
builder.AddAttribute(attribute); // keep the original one as well
}
else if (ExchangeConnectorAttributes.AttMapFromAD.TryGetValue(attribute.Name, out newName))
{
var newAttribute = RenameAttribute(attribute, newName);
builder.AddAttribute(newAttribute);
}
else
{
builder.AddAttribute(attribute);
}
}
builder.AddAttribute(ConnectorAttributeBuilder.Build(ExchangeConnectorAttributes.AttEmailAddressPolicyEnabled, emailAddressPolicyEnabled));
copyAttribute(builder, cobject, ExchangeConnectorAttributes.AttPrimarySmtpAddressADName, ExchangeConnectorAttributes.AttPrimarySmtpAddress);
// derive recipient type
string recipientType = GetRecipientType(cobject);
if (recipientType != null)
{
builder.AddAttribute(ConnectorAttributeBuilder.Build(ExchangeConnectorAttributes.AttRecipientType, new string[] { recipientType }));
}
builder.ObjectClass = cobject.ObjectClass;
builder.SetName(cobject.Name);
builder.SetUid(cobject.Uid);
return(builder.Build());
}
public void TestSimplifyNoAndNoLeaf()
{
Filter a =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("a", "a"));
Filter b =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("b", "b"));
Filter c =
FilterBuilder.EndsWith(ConnectorAttributeBuilder.Build("c", "c"));
Filter d =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("d", "d"));
Filter filter =
FilterBuilder.And(
FilterBuilder.Or(a, b),
FilterBuilder.Or(c, d));
String expected = "( | ( CONTAINS a a ) ( CONTAINS b b ) )";
String actual =
TranslateSingle(new NoAndNoEndsWithTranslator(), filter);
Assert.AreEqual(expected, actual);
a =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("a", "a"));
b =
FilterBuilder.EndsWith(ConnectorAttributeBuilder.Build("b", "b"));
c =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("c", "c"));
d =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("d", "d"));
filter =
FilterBuilder.And(
FilterBuilder.Or(a, b),
FilterBuilder.Or(c, d));
expected = "( | ( CONTAINS c c ) ( CONTAINS d d ) )";
actual =
TranslateSingle(new NoAndNoEndsWithTranslator(), filter);
Assert.AreEqual(expected, actual);
a =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("a", "a"));
b =
FilterBuilder.EndsWith(ConnectorAttributeBuilder.Build("b", "b"));
c =
FilterBuilder.Contains(ConnectorAttributeBuilder.Build("c", "c"));
d =
FilterBuilder.EndsWith(ConnectorAttributeBuilder.Build("d", "d"));
filter =
FilterBuilder.And(
FilterBuilder.Or(a, b),
FilterBuilder.Or(c, d));
IList <String> results =
new NoAndNoEndsWithTranslator().Translate(filter);
Assert.AreEqual(0, results.Count);
}
public void TestUpdate()
{
Uid uid = CreateTestUser("TESTOK01");
var updateAttributes = new List <ConnectorAttribute>(1);
updateAttributes.Add(ConnectorAttributeBuilder.Build("email", "*****@*****.**"));
uid = GetFacade().Update(ObjectClass.ACCOUNT, uid, updateAttributes, null);
}
public void TestNotFilter()
{
ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
NotFilter v1 = new NotFilter(left1);
NotFilter v2 = (NotFilter)CloneObject(v1);
ContainsFilter left2 = (ContainsFilter)v2.Filter;
Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute());
}
public void TestUpdateFailReadOnly()
{
Uid uid = CreateTestUser("FAIL04");
var updateAttributes = new List <ConnectorAttribute>(1);
updateAttributes.Add(ConnectorAttributeBuilder.Build("lastModified", "newValue"));
uid = GetFacade().Update(ObjectClass.ACCOUNT, uid, updateAttributes, null);
Assert.Fail("Connector operation should fail");
}
public void TestUpdateFailMulti()
{
Uid uid = CreateTestUser("FAIL03");
var updateAttributes = new List <ConnectorAttribute>(1);
updateAttributes.Add(ConnectorAttributeBuilder.Build("userName", "name1", "name2"));
uid = GetFacade().Update(ObjectClass.ACCOUNT, uid, updateAttributes, null);
Assert.Fail("Connector operation should fail");
}
public void TestUpdateFailEmpty()
{
Uid uid = CreateTestUser("FAIL01");
var updateAttributes = new List <ConnectorAttribute>(1)
{
ConnectorAttributeBuilder.Build("email")
};
uid = GetFacade().Update(ObjectClass.ACCOUNT, uid, updateAttributes, null);
Assert.Fail("Connector operation should fail");
}
/// <summary>
/// Renames the connector attribute to new name
/// </summary>
/// <param name="cattribute">ConnectorAttribute to be renamed</param>
/// <param name="newName">New attribute name</param>
/// <returns>Renamed ConnectorAttribute</returns>
/// <exception cref="ArgumentNullException">If some of the params is null</exception>
internal static ConnectorAttribute RenameAttribute(ConnectorAttribute cattribute, string newName)
{
Assertions.NullCheck(cattribute, "cattribute");
Assertions.NullCheck(newName, "newName");
var attBuilder = new ConnectorAttributeBuilder();
attBuilder.AddValue(cattribute.Value);
attBuilder.Name = newName;
return(attBuilder.Build());
}
private List <ConnectorAttribute> GetTestUpdateConnectorObject(String name)
{
var attrs = new List <ConnectorAttribute>
{
ConnectorAttributeBuilder.Build("mail", name + "@example2.com"),
ConnectorAttributeBuilder.BuildPassword(new GuardedString(GetSecure(Password + "2"))),
ConnectorAttributeBuilder.BuildEnabled(false)
};
return(attrs);
}
public ConnectorAttribute NormalizeAttribute(ObjectClass oclass, ConnectorAttribute attribute)
{
if (attribute.Is("foo"))
{
String val = ConnectorAttributeUtil.GetStringValue(attribute);
return(ConnectorAttributeBuilder.Build("foo", val.Trim()));
}
else
{
return(attribute);
}
}
public void TestOrFilter()
{
ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
ContainsFilter right1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo2", "bar2"));
OrFilter v1 = new OrFilter(left1, right1);
OrFilter v2 = (OrFilter)CloneObject(v1);
ContainsFilter left2 = (ContainsFilter)v2.Left;
ContainsFilter right2 = (ContainsFilter)v2.Right;
Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute());
Assert.AreEqual(right1.GetAttribute(), right2.GetAttribute());
}
private void AddOrReplaceAttribute(ICollection <ConnectorAttribute> attributes, string name, string value)
{
ConnectorAttribute attribute = GetAttribute(attributes, name);
if (attribute == null)
{
attributes.Add(ConnectorAttributeBuilder.Build(name, new string[] { value }));
}
else
{
attribute.Value.Clear();
attribute.Value.Add(value);
}
}
public void MergeDeleteNonExistentAttribute()
{
UpdateImpl up = new UpdateImpl(null, null);
ICollection <ConnectorAttribute> actual;
ICollection <ConnectorAttribute> baseAttrs = CollectionUtil.NewSet <ConnectorAttribute>();
ICollection <ConnectorAttribute> expected = CollectionUtil.NewSet <ConnectorAttribute>();
ICollection <ConnectorAttribute> changeset = CollectionUtil.NewSet <ConnectorAttribute>();
// attempt to add a value to an attribute..
ConnectorAttribute cattr = ConnectorAttributeBuilder.Build("abc", 2);
changeset.Add(cattr);
actual = up.Merge(changeset, baseAttrs, false);
Assert.IsTrue(AreEqual(expected, actual));
}
public void TestCaseInsensitiveMap()
{
HashSet <ConnectorAttribute> set = new HashSet <ConnectorAttribute>();
set.Add(ConnectorAttributeBuilder.Build("foo1"));
set.Add(ConnectorAttributeBuilder.Build("foo2"));
IDictionary <String, ConnectorAttribute> map = ConnectorAttributeUtil.ToMap(set);
Assert.IsTrue(map.ContainsKey("Foo1"));
Assert.IsTrue(map.ContainsKey("Foo2"));
IDictionary <String, object> map2 = (IDictionary <String, object>)CloneObject(map);
Assert.IsTrue(map2.ContainsKey("Foo1"));
Assert.IsTrue(map2.ContainsKey("Foo2"));
}
/// <summary>
/// This method tries to get name and value from <see cref="PSMemberInfo"/> and
/// creates <see cref="ConnectorAttribute"/> out of it
/// </summary>
/// <param name="info">PSMemberInfo to get the data from</param>
/// <returns>Created ConnectorAttribute or null if not possible to create it</returns>
private static ConnectorAttribute GetAsAttribute(PSMemberInfo info)
{
Assertions.NullCheck(info, "param");
if (info.Value != null)
{
string value = info.Value.ToString();
// TODO: add type recognition, currently only string is supported
if (value != info.Value.GetType().ToString() && !string.IsNullOrEmpty(value))
{
return(ConnectorAttributeBuilder.Build(info.Name, value));
}
}
return(null);
}
public void UpdateCallPattern()
{
TestCallPattern(new TestOperationPattern()
{
MakeCall = facade =>
{
ICollection <ConnectorAttribute> attrs = new HashSet <ConnectorAttribute>();
attrs.Add(ConnectorAttributeBuilder.Build("accountid"));
facade.Update(ObjectClass.ACCOUNT, NewUid(0), attrs, null);
},
CheckCalls = calls =>
{
Assert.AreEqual("Update", GetAndRemoveMethodName(calls));
}
});
}
public void UpdateAllCallPattern()
{
TestCallPattern(new TestOperationPattern()
{
MakeCall = facade =>
{
ICollection <ConnectorAttribute> attrs = new HashSet <ConnectorAttribute>();
attrs.Add(ConnectorAttributeBuilder.Build("accountid"));
facade.Update(ObjectClass.ALL, NewUid(0), attrs, null);
},
CheckCalls = calls =>
{
Assert.Fail("Should not get here..");
}
});
}
/// <summary>
/// Helper method: Sets attribute value in the attribute collection
/// </summary>
/// <param name="attName">attribute name</param>
/// <param name="attValue">attribute value (if null, we will remove the attribute from the collection)</param>
/// <param name="attributes">collection of attribute</param>
/// <exception cref="ArgumentNullException">If some of the params is null</exception>
internal static void SetAttValue(string attName, object attValue, ICollection <ConnectorAttribute> attributes)
{
Assertions.NullCheck(attName, "attName");
Assertions.NullCheck(attributes, "attributes");
ConnectorAttribute attribute = ConnectorAttributeUtil.Find(attName, attributes);
if (attribute != null)
{
attributes.Remove(attribute);
}
if (attValue != null)
{
attributes.Add(ConnectorAttributeBuilder.Build(attName, new object[] { attValue }));
}
}
public void createDuplicatConnectorAttributesPattern()
{
TestCallPattern(new TestOperationPattern()
{
MakeCall = facade =>
{
ICollection <ConnectorAttribute> attrs = new HashSet <ConnectorAttribute>();
attrs.Add(ConnectorAttributeBuilder.Build("abc", 1));
attrs.Add(ConnectorAttributeBuilder.Build("abc", 2));
facade.Create(ObjectClass.ACCOUNT, attrs, null);
},
CheckCalls = calls =>
{
Assert.Fail("Should not get here..");
}
});
}
