public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
TransformKeyedCollection objectToSerialize = new TransformKeyedCollection();
StringCaseTransform transform1 = new StringCaseTransform();
transform1.ID = "tx0001";
transform1.StringCase = StringCaseType.Title;
GetDNComponentTransform transform2 = new GetDNComponentTransform();
transform2.ID = "tx0002";
transform2.RdnFormat = RdnFormat.ValueOnly;
transform2.ComponentIndex = 1;
objectToSerialize.Add(transform1);
objectToSerialize.Add(transform2);
UniqueIDCache.ClearIdCache();
TransformKeyedCollection deserializedObject = (TransformKeyedCollection)UnitTestControl.XmlSerializeRoundTrip <TransformKeyedCollection>(objectToSerialize);
Assert.AreEqual(objectToSerialize.Count, deserializedObject.Count);
Assert.AreEqual(objectToSerialize[0].ID, transform1.ID);
Assert.AreEqual(objectToSerialize[1].ID, transform2.ID);
}
public void TestSerialization()
{
SequentialIntegerAllocationConstructor toSeralize = new SequentialIntegerAllocationConstructor();
toSeralize.Attribute = ActiveConfig.DB.GetAttribute("sn");
toSeralize.ID = "abc12355";
toSeralize.Description = "some description";
toSeralize.Sequence = ActiveConfig.DB.GetSequence("unixUid");
toSeralize.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
toSeralize.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Delete
});
UniqueIDCache.ClearIdCache();
SequentialIntegerAllocationConstructor deserialized = UnitTestControl.XmlSerializeRoundTrip <SequentialIntegerAllocationConstructor>(toSeralize);
Assert.AreEqual(toSeralize.Attribute, deserialized.Attribute);
Assert.AreEqual(toSeralize.ID, deserialized.ID);
Assert.AreEqual(toSeralize.Description, deserialized.Description);
Assert.AreEqual(toSeralize.Sequence, deserialized.Sequence);
Assert.AreEqual(toSeralize.RuleGroup.Operator, deserialized.RuleGroup.Operator);
Assert.AreEqual(((ObjectChangeRule)toSeralize.RuleGroup.Items[0]).TriggerEvents, ((ObjectChangeRule)deserialized.RuleGroup.Items[0]).TriggerEvents);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
MVBooleanToBitmaskTransform transformToSeralize = new MVBooleanToBitmaskTransform();
transformToSeralize.ID = "test001";
transformToSeralize.Flags.Add(new FlagValue()
{
Name = "AccountDisabled", Value = 2
});
transformToSeralize.Flags.Add(new FlagValue()
{
Name = "DontExpirePassword", Value = 65535
});
transformToSeralize.DefaultValue = 512;
UniqueIDCache.ClearIdCache();
MVBooleanToBitmaskTransform deserializedTransform = (MVBooleanToBitmaskTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.Flags[0].Name, deserializedTransform.Flags[0].Name);
Assert.AreEqual(transformToSeralize.Flags[1].Name, deserializedTransform.Flags[1].Name);
Assert.AreEqual(transformToSeralize.Flags[0].Value, deserializedTransform.Flags[0].Value);
Assert.AreEqual(transformToSeralize.Flags[1].Value, deserializedTransform.Flags[1].Value);
Assert.AreEqual(transformToSeralize.DefaultValue, deserializedTransform.DefaultValue);
}
protected override void ValidatePropertyChange(string propertyName)
{
switch (propertyName)
{
case "Id":
if (string.IsNullOrWhiteSpace(this.Id))
{
this.AddError("Id", "An ID must be specified");
}
else
{
if (Regex.IsMatch(this.Id, @"[^a-zA-Z0-9]+"))
{
this.AddError("Id", "The ID must contain only letters, numbers, hyphen, and underscores");
}
else if (UniqueIDCache.IsIdInUse(this.Id, this.Model, "transform"))
{
this.AddError("Id", "The specified ID is already in use");
}
else
{
this.RemoveError("Id");
}
}
break;
default:
break;
}
}
public FlowRuleParameterTests()
{
UniqueIDCache.ClearIdCache();
this.config = new XmlConfigFile();
GetDNComponentTransform transform1 = new GetDNComponentTransform();
transform1.ID = "xform1";
this.config.Transforms.Add(transform1);
GetDNComponentTransform transform2 = new GetDNComponentTransform();
transform2.ID = "xform2";
this.config.Transforms.Add(transform2);
MVBooleanToBitmaskTransform transform3 = new MVBooleanToBitmaskTransform();
transform3.ID = "loopback";
this.config.Transforms.Add(transform3);
FlowRuleAlias alias1 = new FlowRuleAlias();
alias1.Alias = "alias1";
alias1.FlowRuleDefinition = "csattribute>>xform1>>mvattribute";
this.config.FlowRuleAliases.Add(alias1);
FlowRuleAlias alias2 = new FlowRuleAlias();
alias2.Alias = "alias2";
alias2.FlowRuleDefinition = "csattribute>>xform2>>mvattribute";
this.config.FlowRuleAliases.Add(alias2);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
SimpleLookupTransform transformToSeralize = new SimpleLookupTransform();
transformToSeralize.DefaultValue = "A";
transformToSeralize.LookupItems.Add(new LookupItem()
{
CurrentValue = "test1", NewValue = "test2"
});
transformToSeralize.LookupItems.Add(new LookupItem()
{
CurrentValue = "test3", NewValue = "test4"
});
transformToSeralize.OnMissingMatch = OnMissingMatch.UseNull;
transformToSeralize.UserDefinedReturnType = ExtendedAttributeType.Binary;
transformToSeralize.ID = "test001";
UniqueIDCache.ClearIdCache();
SimpleLookupTransform deserializedTransform = (SimpleLookupTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.DefaultValue, deserializedTransform.DefaultValue);
Assert.AreEqual(transformToSeralize.OnMissingMatch, deserializedTransform.OnMissingMatch);
Assert.AreEqual(transformToSeralize.UserDefinedReturnType, deserializedTransform.UserDefinedReturnType);
CollectionAssert.AreEqual(transformToSeralize.LookupItems, deserializedTransform.LookupItems, new LookupItemComparer());
}
public static XmlConfigFile LoadXml(string filename)
{
if (!Path.IsPathRooted(filename))
{
filename = Path.Combine(Utils.ExtensionsDirectory, filename);
}
bool canCache = ActiveConfig.DB.CanCache;
try
{
UniqueIDCache.ClearIdCache();
ActiveConfig.DB.CanCache = true;
// XmlConfigFile configFile = Serializer.Read<XmlConfigFile>(filename);
XmlConfigFile configFile = Serializer.Read <XmlConfigFile>(filename, "acma", "http://lithnet.local/Lithnet.Acma/v1/");
configFile.FileName = filename;
ActiveConfig.XmlConfig = configFile;
if (ActiveConfig.XmlConfigChanged != null)
{
ActiveConfig.XmlConfigChanged(null, new EventArgs());
}
}
finally
{
ActiveConfig.DB.CanCache = canCache;
}
return(ActiveConfig.XmlConfig);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
DateConverterTransform transformToSeralize = new DateConverterTransform();
transformToSeralize.ID = "test001";
transformToSeralize.InputDateType = DateType.FimServiceString;
transformToSeralize.InputFormat = "abc";
transformToSeralize.InputTimeZone = TimeZoneInfo.Utc;
transformToSeralize.CalculationOperator = DateOperator.Add;
transformToSeralize.CalculationTimeSpanType = TimeSpanType.Hours;
transformToSeralize.CalculationValue = 6;
transformToSeralize.OutputDateType = DateType.String;
transformToSeralize.OutputFormat = "def";
transformToSeralize.OutputTimeZone = TimeZoneInfo.Local;
UniqueIDCache.ClearIdCache();
DateConverterTransform deserializedTransform = (DateConverterTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.InputDateType, deserializedTransform.InputDateType);
Assert.AreEqual(transformToSeralize.InputFormat, deserializedTransform.InputFormat);
Assert.AreEqual(transformToSeralize.InputTimeZone, deserializedTransform.InputTimeZone);
Assert.AreEqual(transformToSeralize.CalculationOperator, deserializedTransform.CalculationOperator);
Assert.AreEqual(transformToSeralize.CalculationTimeSpanType, deserializedTransform.CalculationTimeSpanType);
Assert.AreEqual(transformToSeralize.CalculationValue, deserializedTransform.CalculationValue);
Assert.AreEqual(transformToSeralize.OutputFormat, deserializedTransform.OutputFormat);
Assert.AreEqual(transformToSeralize.OutputDateType, deserializedTransform.OutputDateType);
Assert.AreEqual(transformToSeralize.OutputTimeZone, deserializedTransform.OutputTimeZone);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
DelimitedTextFileLookupTransform transformToSeralize = new DelimitedTextFileLookupTransform();
transformToSeralize.DefaultValue = "A";
transformToSeralize.FileName = "B";
transformToSeralize.FindColumn = 1;
transformToSeralize.HasHeaderRow = true;
transformToSeralize.OnMissingMatch = OnMissingMatch.UseNull;
transformToSeralize.ReplaceColumn = 5;
transformToSeralize.ID = "test001";
transformToSeralize.CustomDelimiterRegex = "1234";
transformToSeralize.DelimiterType = DelimiterType.Custom;
transformToSeralize.CustomEscapeSequence = "\\";
transformToSeralize.UserDefinedReturnType = ExtendedAttributeType.Integer;
UniqueIDCache.ClearIdCache();
DelimitedTextFileLookupTransform deserializedTransform = (DelimitedTextFileLookupTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.DefaultValue, deserializedTransform.DefaultValue);
Assert.AreEqual(transformToSeralize.FileName, deserializedTransform.FileName);
Assert.AreEqual(transformToSeralize.FindColumn, deserializedTransform.FindColumn);
Assert.AreEqual(transformToSeralize.HasHeaderRow, deserializedTransform.HasHeaderRow);
Assert.AreEqual(transformToSeralize.OnMissingMatch, deserializedTransform.OnMissingMatch);
Assert.AreEqual(transformToSeralize.ReplaceColumn, deserializedTransform.ReplaceColumn);
Assert.AreEqual(transformToSeralize.CustomDelimiterRegex, deserializedTransform.CustomDelimiterRegex);
Assert.AreEqual(transformToSeralize.DelimiterType, deserializedTransform.DelimiterType);
Assert.AreEqual(transformToSeralize.CustomEscapeSequence, deserializedTransform.CustomEscapeSequence);
Assert.AreEqual(transformToSeralize.UserDefinedReturnType, deserializedTransform.UserDefinedReturnType);
}
private void TransformCollectionViewModel_OnModelRemoved(ListViewModelChangedEventArgs args)
{
Transform transform = args.Model as Transform;
if (transform != null)
{
UniqueIDCache.RemoveItem(transform, Transform.CacheGroupName);
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
UniqueIDCache.RemoveItem(this, "transform");
}
}
disposed = true;
}
private void RemoveIDsFromCache(UnitTestObject item)
{
UniqueIDCache.RemoveItem(item, UnitTestObject.CacheGroupName);
if (item is UnitTestGroup)
{
foreach (UnitTestObject child in ((UnitTestGroup)item).UnitTestObjects)
{
this.RemoveIDsFromCache(child);
}
}
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
GroupStringsToADGroupTypeTransform transformToSeralize = new GroupStringsToADGroupTypeTransform();
transformToSeralize.ID = "test001";
UniqueIDCache.ClearIdCache();
GroupStringsToADGroupTypeTransform deserializedTransform = (GroupStringsToADGroupTypeTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
SidStringBiDirectionalTransform transformToSeralize = new SidStringBiDirectionalTransform();
transformToSeralize.ID = "test001";
UniqueIDCache.ClearIdCache();
SidStringBiDirectionalTransform deserializedTransform = (SidStringBiDirectionalTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
}
private void RemoveIDsFromCache(ExecutableConstructorObject constructor)
{
UniqueIDCache.RemoveItem(constructor, ExecutableConstructorObject.CacheGroupName);
if (constructor is AttributeConstructorGroup)
{
foreach (ExecutableConstructorObject child in ((AttributeConstructorGroup)constructor).Constructors)
{
this.RemoveIDsFromCache(child);
}
}
}
public void TestSerialization()
{
EventRule toSeralize = new EventRule();
toSeralize.EventName = "attribute";
toSeralize.EventSource = ActiveConfig.DB.GetAttribute("supervisor");
UniqueIDCache.ClearIdCache();
EventRule deserialized = (EventRule)UnitTestControl.XmlSerializeRoundTrip <EventRule>(toSeralize);
Assert.AreEqual(toSeralize.EventName, deserialized.EventName);
Assert.AreEqual(toSeralize.EventSource, deserialized.EventSource);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
FormatStringTransform transformToSeralize = new FormatStringTransform();
transformToSeralize.ID = "test001";
transformToSeralize.Format = "{0}\n{1}";
UniqueIDCache.ClearIdCache();
FormatStringTransform deserializedTransform = (FormatStringTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.Format, deserializedTransform.Format);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
ConditionalStringFlowTransform transformToSeralize = new ConditionalStringFlowTransform();
transformToSeralize.ID = "test001";
transformToSeralize.ComparisonType = StringComparison.InvariantCulture;
UniqueIDCache.ClearIdCache();
ConditionalStringFlowTransform deserializedTransform = (ConditionalStringFlowTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.ComparisonType, deserializedTransform.ComparisonType);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
BitmaskToBooleanTransform transformToSeralize = new BitmaskToBooleanTransform();
transformToSeralize.ID = "test001";
transformToSeralize.Flag = 2;
UniqueIDCache.ClearIdCache();
BitmaskToBooleanTransform deserializedTransform = (BitmaskToBooleanTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.Flag, deserializedTransform.Flag);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
StringSplitTransform transformToSeralize = new StringSplitTransform();
transformToSeralize.ID = "test001";
transformToSeralize.SplitRegex = ",";
UniqueIDCache.ClearIdCache();
StringSplitTransform deserializedTransform = (StringSplitTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.SplitRegex, deserializedTransform.SplitRegex);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
StringCaseTransform transformToSeralize = new StringCaseTransform();
transformToSeralize.ID = "test001";
transformToSeralize.StringCase = StringCaseType.Title;
UniqueIDCache.ClearIdCache();
StringCaseTransform deserializedTransform = (StringCaseTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.StringCase, deserializedTransform.StringCase);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
SidToDomainTransform transformToSeralize = new SidToDomainTransform();
transformToSeralize.ID = "test001";
transformToSeralize.Format = DomainFormat.DomainName;
UniqueIDCache.ClearIdCache();
SidToDomainTransform deserializedTransform = (SidToDomainTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.Format, deserializedTransform.Format);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
ConcatStringTransform transformToSeralize = new ConcatStringTransform();
transformToSeralize.ID = "test001";
transformToSeralize.Delimiter = ",";
UniqueIDCache.ClearIdCache();
ConcatStringTransform deserializedTransform = (ConcatStringTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.Delimiter, deserializedTransform.Delimiter);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
ValueMergeTransform transformToSeralize = new ValueMergeTransform();
transformToSeralize.ID = "test001";
transformToSeralize.UserDefinedReturnType = ExtendedAttributeType.Integer;
UniqueIDCache.ClearIdCache();
ValueMergeTransform deserializedTransform = (ValueMergeTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.UserDefinedReturnType, deserializedTransform.UserDefinedReturnType);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
TrimStringTransform transformToSeralize = new TrimStringTransform();
transformToSeralize.ID = "test001";
transformToSeralize.TrimType = TrimType.Both;
UniqueIDCache.ClearIdCache();
TrimStringTransform deserializedTransform = (TrimStringTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.TrimType, deserializedTransform.TrimType);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
BooleanOperationTransform transformToSeralize = new BooleanOperationTransform();
transformToSeralize.ID = "test001";
transformToSeralize.Operator = BitwiseOperation.And;
UniqueIDCache.ClearIdCache();
BooleanOperationTransform deserializedTransform = (BooleanOperationTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.Operator, deserializedTransform.Operator);
}
public void TestSerialization()
{
UniqueIDCache.ClearIdCache();
RegexReplaceTransform transformToSeralize = new RegexReplaceTransform();
transformToSeralize.ID = "test001";
transformToSeralize.FindPattern = "zz";
transformToSeralize.ReplacePattern = "aa";
UniqueIDCache.ClearIdCache();
RegexReplaceTransform deserializedTransform = (RegexReplaceTransform)UnitTestControl.XmlSerializeRoundTrip <Transform>(transformToSeralize);
Assert.AreEqual(transformToSeralize.ID, deserializedTransform.ID);
Assert.AreEqual(transformToSeralize.FindPattern, deserializedTransform.FindPattern);
Assert.AreEqual(transformToSeralize.ReplacePattern, deserializedTransform.ReplacePattern);
}
public void New()
{
ActiveConfig.DB.CanCache = true;
UINotifyPropertyChanges.BeginIgnoreAllChanges();
UniqueIDCache.ClearIdCache();
this.Model = new XmlConfigFile();
this.unitTestFile = new TestEngine.UnitTestFile();
ActiveConfig.XmlConfig = this.Model;
UINotifyPropertyChanges.EndIgnoreAllChanges();
this.ReloadRootNodes();
this.RaisePropertyChanged("DisplayName");
this.RaisePropertyChanged("ChildNodes");
this.ResetChangeState();
ActiveConfig.DB.CanCache = false;
}
private static AcmaEvent GetAccountNameChangedEvent()
{
UniqueIDCache.ClearIdCache();
AcmaInternalExitEvent maevent = new AcmaInternalExitEvent();
maevent.ID = "AccountNameChanged";
maevent.Recipients.Add(ActiveConfig.DB.GetAttribute("supervisor"));
maevent.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
maevent.RuleGroup.Items.Add(new AttributeChangeRule()
{
Attribute = ActiveConfig.DB.GetAttribute("accountName"), TriggerEvents = TriggerEvents.Add | TriggerEvents.Delete | TriggerEvents.Update
});
return(maevent);
}
public static UnitTestFile LoadXml(string filename)
{
bool canCache = ActiveConfig.DB.CanCache;
try
{
UniqueIDCache.ClearIdCache(UnitTest.CacheGroupName);
ActiveConfig.DB.CanCache = true;
UnitTestFile configFile = Serializer.Read <UnitTestFile>(filename, "acma-unit-tests", "http://lithnet.local/Lithnet.Acma/v1/");
configFile.FileName = filename;
return(configFile);
}
finally
{
ActiveConfig.DB.CanCache = canCache;
}
}
