public void TestThatConstructorInitializeDataSetterWithCriteriaConfigurations()
{
var fixture = new Fixture();
fixture.Customize <Tuple <Type, string, object> >(e => e.FromFactory(() => new Tuple <Type, string, object>(typeof(EqualCriteria <>), fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>())));
var tableName = fixture.CreateAnonymous <string>();
var fieldName = fixture.CreateAnonymous <string>();
var fieldValue = fixture.CreateAnonymous <string>();
var criteriaConfigurations = fixture.CreateMany <Tuple <Type, string, object> >(5).ToList();
var dataSetter = new DataSetter(tableName, fieldName, fieldValue, criteriaConfigurations);
Assert.That(dataSetter, Is.Not.Null);
Assert.That(dataSetter.TableName, Is.Not.Null);
Assert.That(dataSetter.TableName, Is.Not.Empty);
Assert.That(dataSetter.TableName, Is.EqualTo(tableName));
Assert.That(dataSetter.FieldName, Is.Not.Null);
Assert.That(dataSetter.FieldName, Is.Not.Empty);
Assert.That(dataSetter.FieldName, Is.EqualTo(fieldName));
Assert.That(dataSetter.FieldValue, Is.Not.Null);
Assert.That(dataSetter.FieldValue, Is.EqualTo(fieldValue));
Assert.That(dataSetter.CriteriaConfigurations, Is.Not.Null);
Assert.That(dataSetter.CriteriaConfigurations, Is.Not.Empty);
Assert.That(dataSetter.CriteriaConfigurations, Is.EqualTo(criteriaConfigurations));
}
public void TestThatManipulateDataThrowsArgumentNullExceptionIfTableIsNull()
{
var fixture = new Fixture();
var dataSetter = new DataSetter(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>());
Assert.That(dataSetter, Is.Not.Null);
Assert.Throws <ArgumentNullException>(() => dataSetter.ManipulateData(null, new Collection <IEnumerable <IDataObjectBase> >()));
}
public void TestThatManipulateDataChangesFieldValueWithoutUsingCriterias()
{
var fixture = new Fixture();
fixture.Customize <Type>(e => e.FromFactory(() => typeof(int)));
fixture.Customize <IMap>(e => e.FromFactory(() => MockRepository.GenerateMock <IMap>()));
fixture.Customize <IField>(e => e.FromFactory(() =>
{
var fieldMock = MockRepository.GenerateMock <IField>();
fieldMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
return(fieldMock);
}));
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fixture.CreateMany <IField>(5).ToList())))
.Repeat.Any();
fixture.Customize <ITable>(e => e.FromFactory(() => tableMock));
var dataCollectionMock = new Collection <IEnumerable <IDataObjectBase> >();
while (dataCollectionMock.Count < 250)
{
var dataObjects = new Collection <IDataObjectBase>();
for (var i = 0; i < tableMock.Fields.Count; i++)
{
var dataObject = MockRepository.GenerateMock <IFieldData <int, int> >();
dataObject.Expect(m => m.Field)
.Return(tableMock.Fields.ElementAt(i))
.Repeat.Any();
dataObjects.Add(dataObject);
}
dataCollectionMock.Add(dataObjects);
}
var newFieldValue = fixture.CreateAnonymous <int>();
var dataSetter = new DataSetter(tableMock.NameSource, tableMock.Fields.ElementAt(3).NameSource, newFieldValue);
Assert.That(dataSetter, Is.Not.Null);
var manipulatedData = dataSetter.ManipulateData(fixture.CreateAnonymous <ITable>(), dataCollectionMock);
Assert.That(manipulatedData, Is.Not.Null);
foreach (var dataObjects in manipulatedData)
{
dataObjects.ElementAt(3).AssertWasCalled(m => m.UpdateSourceValue(Arg <int> .Is.Equal(newFieldValue)));
}
}
public void TestThatIsManipulatingFieldReturnsFalseIfDataManipulatorIsNotManipulatingFieldName()
{
var fixture = new Fixture();
var fieldForDataManipulator = fixture.CreateAnonymous <string>();
var dataSetter = new DataSetter(fixture.CreateAnonymous <string>(), fieldForDataManipulator, fixture.CreateAnonymous <object>());
Assert.That(dataSetter, Is.Not.Null);
Assert.That(dataSetter.IsManipulatingField(fixture.CreateAnonymous <string>()), Is.False);
}
public void TestThatManipulateDataThrowsArgumentNullExceptionIfDataIsNull()
{
var fixture = new Fixture();
fixture.Customize <ITable>(e => e.FromFactory(() => MockRepository.GenerateMock <ITable>()));
var dataSetter = new DataSetter(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>());
Assert.That(dataSetter, Is.Not.Null);
Assert.Throws <ArgumentNullException>(() => dataSetter.ManipulateData(fixture.CreateAnonymous <ITable>(), null));
}
public void buttonClick()
{
if (!Main.canSave)
{
Debug.Log("Must choose father and mother powers first");
}
else
{
DataSetter.setGlobalData();
DataSetter.setPlayerData();
SceneManager.LoadScene("The City", LoadSceneMode.Single);
}
}
private void button1_Click(object sender, EventArgs e)
{
DataSetter SetData = new DataSetter();
int counter = 0;
foreach (ListViewItem item in listView1.SelectedItems)
{
counter++;
SetData.RemoveEventReservations(int.Parse(item.SubItems[3].Text));
}
MessageBox.Show($"Removed {counter} ticket(s).");
this.Hide();
Order.RemoveData();
}
private void BtnCheckout_Click(object sender, EventArgs e)
{
Order.Customer.FirstName = txtFirst.Text;
Order.Customer.LastName = txtLast.Text;
Order.Customer.PhoneNr = txtPhone.Text;
DataSetter SetData = new DataSetter();
SetData.SetCustomer(Order.Customer.PhoneNr, Order.Customer.FirstName, Order.Customer.LastName);
LoadEventReservations();
SetData.SetEventReservation();
MessageBox.Show($"You booked {Order.Reservations.Count} ticket(s).");
Order.RemoveData();
listSeats.Items.Clear();
this.Hide();
}
public void TestThatManipulateDataReturnsWithoutManipulatingDataIfTableSourceNameDoesNotMatchTableNameInTheConstructor()
{
var fixture = new Fixture();
fixture.Customize <Type>(e => e.FromFactory(() => typeof(int)));
fixture.Customize <IMap>(e => e.FromFactory(() => MockRepository.GenerateMock <IMap>()));
fixture.Customize <IField>(e => e.FromFactory(() => MockRepository.GenerateMock <IField>()));
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fixture.CreateMany <IField>(5).ToList())))
.Repeat.Any();
fixture.Customize <ITable>(e => e.FromFactory(() => tableMock));
var dataCollectionMock = new Collection <IEnumerable <IDataObjectBase> >();
while (dataCollectionMock.Count < 250)
{
var dataObjects = new Collection <IDataObjectBase>();
for (var i = 0; i < tableMock.Fields.Count; i++)
{
var dataObject = MockRepository.GenerateMock <IFieldData <int, int> >();
dataObject.Expect(m => m.GetSourceValue <int>())
.Return(i)
.Repeat.Any();
dataObjects.Add(dataObject);
}
dataCollectionMock.Add(dataObjects);
}
var dataSetter = new DataSetter(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>());
Assert.That(dataSetter, Is.Not.Null);
var manipulatedData = dataSetter.ManipulateData(fixture.CreateAnonymous <ITable>(), dataCollectionMock);
Assert.That(manipulatedData, Is.Not.Null);
foreach (var dataObjects in manipulatedData)
{
Assert.That(dataObjects.ElementAt(3).GetSourceValue <int>(), Is.EqualTo(3));
}
}
public void TestThatConstructorInitializeDataSetterWithoutCriteriaConfigurations()
{
var fixture = new Fixture();
var tableName = fixture.CreateAnonymous <string>();
var fieldName = fixture.CreateAnonymous <string>();
var fieldValue = fixture.CreateAnonymous <object>();
var dataSetter = new DataSetter(tableName, fieldName, fieldValue);
Assert.That(dataSetter, Is.Not.Null);
Assert.That(dataSetter.TableName, Is.Not.Null);
Assert.That(dataSetter.TableName, Is.Not.Empty);
Assert.That(dataSetter.TableName, Is.EqualTo(tableName));
Assert.That(dataSetter.FieldName, Is.Not.Null);
Assert.That(dataSetter.FieldName, Is.Not.Empty);
Assert.That(dataSetter.FieldName, Is.EqualTo(fieldName));
Assert.That(dataSetter.FieldValue, Is.Not.Null);
Assert.That(dataSetter.FieldValue, Is.EqualTo(fieldValue));
Assert.That(dataSetter.CriteriaConfigurations, Is.Not.Null);
Assert.That(dataSetter.CriteriaConfigurations, Is.Empty);
}
public DataModel()
{
data = PlayerGameData.CreateDataWithDefaultValues();
dataSetter = new DataSetter(data);
}
public void TestThatManipulateDataChangesFieldValueUsingIntervalCriterias()
{
var fixture = new Fixture();
fixture.Customize <Type>(e => e.FromFactory(() => typeof(int)));
fixture.Customize <IMap>(e => e.FromFactory(() => MockRepository.GenerateMock <IMap>()));
fixture.Customize <IField>(e => e.FromFactory(() =>
{
var fieldMock = MockRepository.GenerateMock <IField>();
fieldMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
fieldMock.Expect(m => m.DatatypeOfSource)
.Return(typeof(int))
.Repeat.Any();
return(fieldMock);
}));
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fixture.CreateMany <IField>(5).ToList())))
.Repeat.Any();
fixture.Customize <ITable>(e => e.FromFactory(() => tableMock));
var criteriaCollectionMock = new Collection <Tuple <Type, string, object> >
{
new Tuple <Type, string, object>(typeof(IntervalCriteria <>), tableMock.Fields.ElementAt(0).NameSource, new Tuple <string, string>("1", "3"))
};
var dataCollectionMock = new Collection <IEnumerable <IDataObjectBase> >();
while (dataCollectionMock.Count < 250)
{
var dataObjects = new Collection <IDataObjectBase>();
for (var i = 0; i < tableMock.Fields.Count; i++)
{
var dataObject = MockRepository.GenerateMock <IFieldData <int, int> >();
dataObject.Expect(m => m.Field)
.Return(tableMock.Fields.ElementAt(i))
.Repeat.Any();
dataObject.Expect(m => m.SourceValue)
.Return(i == 0 ? dataCollectionMock.Count % 4 : i)
.Repeat.Any();
dataObject.Expect(m => m.GetSourceValue <int>())
.Return(dataObject.SourceValue)
.Repeat.Any();
dataObjects.Add(dataObject);
}
dataCollectionMock.Add(dataObjects);
}
var newFieldValue = fixture.CreateAnonymous <int>();
var dataSetter = new DataSetter(tableMock.NameSource, tableMock.Fields.ElementAt(3).NameSource, newFieldValue, criteriaCollectionMock);
Assert.That(dataSetter, Is.Not.Null);
var manipulatedData = dataSetter.ManipulateData(fixture.CreateAnonymous <ITable>(), dataCollectionMock);
Assert.That(manipulatedData, Is.Not.Null);
var dataRows = manipulatedData.ToList();
for (var i = 0; i < dataRows.Count; i++)
{
if (dataRows.ElementAt(i).ElementAt(0).GetSourceValue <int>() > 0)
{
dataRows.ElementAt(i).ElementAt(3).AssertWasCalled(m => m.UpdateSourceValue(Arg <int> .Is.Equal(newFieldValue)));
continue;
}
dataRows.ElementAt(i).ElementAt(3).AssertWasNotCalled(m => m.UpdateSourceValue(Arg <int> .Is.Anything));
}
}
public void Init()
{
_dataSetter = new DataSetter(null);
}
public ChangePropagator(NativeArray <Entity> targets, DataGetter <TData> getter, DataSetter <TData> setter)
{
m_Targets = targets;
m_Getter = getter;
m_Setter = setter;
}
/// <summary>
/// Adding configuration to the container for Inversion of Control.
/// </summary>
/// <param name="container">Container for Inversion of Control.</param>
public void AddConfiguration(IWindsorContainer container)
{
var dataManipulatorsFileName = ConfigurationManager.AppSettings["DataManipulatorsFileName"];
if (dataManipulatorsFileName == null)
{
throw new DeliveryEngineSystemException(Resource.GetExceptionMessage(ExceptionMessage.ApplicationSettingMissing, "DataManipulatorsFileName"));
}
dataManipulatorsFileName = Environment.ExpandEnvironmentVariables(dataManipulatorsFileName);
if (string.IsNullOrEmpty(dataManipulatorsFileName))
{
container.Register(Component.For <IDataManipulators>().ImplementedBy <DataManipulators>().LifeStyle.Transient);
return;
}
if (!File.Exists(dataManipulatorsFileName))
{
throw new DeliveryEngineSystemException(Resource.GetExceptionMessage(ExceptionMessage.FileNotFound, dataManipulatorsFileName));
}
var assembly = typeof(DataManipulators).Assembly;
using (var resourceStream = assembly.GetManifestResourceStream(string.Format("{0}.Schemas.DataManipulators.xsd", assembly.GetName().Name)))
{
if (resourceStream == null)
{
throw new DeliveryEngineSystemException(Resource.GetExceptionMessage(ExceptionMessage.ResourceNotFound, string.Format("{0}.Schemas.DataManipulators.xsd", assembly.GetName().Name)));
}
var schema = XmlSchema.Read(resourceStream, ValidationEventHandler);
var readerSettings = new XmlReaderSettings
{
IgnoreComments = true,
IgnoreProcessingInstructions = true,
IgnoreWhitespace = true,
ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings,
ValidationType = ValidationType.Schema
};
readerSettings.Schemas.Add(schema);
readerSettings.ValidationEventHandler += ValidationEventHandler;
var reader = XmlReader.Create(dataManipulatorsFileName, readerSettings);
try
{
var document = new XmlDocument();
document.Load(reader);
var namespaceManager = new XmlNamespaceManager(document.NameTable);
namespaceManager.AddNamespace("ns", schema.TargetNamespace);
var dataSetterNodeList = document.SelectNodes("/ns:DataManipulators/ns:DataSetter", namespaceManager);
if (dataSetterNodeList != null && dataSetterNodeList.Count > 0)
{
var dataSetterNo = 0;
foreach (XmlNode dataSetterNode in dataSetterNodeList)
{
var criteriaConfigurations = GenerateCriteriaConfigurations(dataSetterNode.SelectNodes("ns:EqualCriteria | ns:PoolCriteria | ns:IntervalCriteria", namespaceManager));
// ReSharper disable PossibleNullReferenceException
var dataSetter = new DataSetter(dataSetterNode.Attributes["table"].Value, dataSetterNode.SelectSingleNode("ns:Field", namespaceManager).Attributes["name"].Value, dataSetterNode.SelectSingleNode("ns:Field", namespaceManager).Attributes["value"].Value, criteriaConfigurations);
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IDataSetter>().Named(string.Format("{0}[{1}]", typeof(IDataSetter).Name, dataSetterNo++)).Instance(dataSetter).LifeStyle.Transient);
}
}
var regularExpressionReplacerNodeList = document.SelectNodes("/ns:DataManipulators/ns:RegularExpressionReplacer", namespaceManager);
if (regularExpressionReplacerNodeList != null && regularExpressionReplacerNodeList.Count > 0)
{
var regularExpressionReplacerNo = 0;
foreach (XmlNode regularExpressionReplacerNode in regularExpressionReplacerNodeList)
{
var fieldNode = regularExpressionReplacerNode.SelectSingleNode("ns:Field", namespaceManager);
// ReSharper disable PossibleNullReferenceException
var regularExpression = new Regex(fieldNode.Attributes["regularExpression"].Value, RegexOptions.Compiled);
var newFieldValue = fieldNode.Attributes["value"].Value;
var regularExpressionReplacer = new RegularExpressionReplacer(regularExpressionReplacerNode.Attributes["table"].Value, regularExpression, (RegularExpressionApplyOn)Enum.Parse(typeof(RegularExpressionApplyOn), fieldNode.Attributes["applyOn"].Value), fieldNode.Attributes["name"].Value, Equals(newFieldValue, "{null}") ? null : newFieldValue);
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IRegularExpressionReplacer>().Named(string.Format("{0}[{1}]", typeof(IRegularExpressionReplacer).Name, regularExpressionReplacerNo++)).Instance(regularExpressionReplacer).LifeStyle.Transient);
}
}
var rowDuplicatorNodeList = document.SelectNodes("/ns:DataManipulators/ns:RowDuplicator", namespaceManager);
if (rowDuplicatorNodeList != null && rowDuplicatorNodeList.Count > 0)
{
var rowDuplicatorNo = 0;
foreach (XmlNode rowDuplicatorNode in rowDuplicatorNodeList)
{
var criteriaConfigurations = GenerateCriteriaConfigurations(rowDuplicatorNode.SelectNodes("ns:EqualCriteria | ns:PoolCriteria | ns:IntervalCriteria", namespaceManager));
var fieldUpdates = new Collection <Tuple <string, object> >();
var fieldNodeList = rowDuplicatorNode.SelectNodes("ns:Field", namespaceManager);
if (fieldNodeList != null && fieldNodeList.Count > 0)
{
foreach (XmlNode fieldNode in fieldNodeList)
{
// ReSharper disable PossibleNullReferenceException
fieldUpdates.Add(new Tuple <string, object>(fieldNode.Attributes["name"].Value, fieldNode.Attributes["value"].Value));
// ReSharper restore PossibleNullReferenceException
}
}
// ReSharper disable PossibleNullReferenceException
var rowDuplicator = new RowDuplicator(rowDuplicatorNode.Attributes["table"].Value, fieldUpdates, criteriaConfigurations);
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IRowDuplicator>().Named(string.Format("{0}[{1}]", typeof(IRowDuplicator).Name, rowDuplicatorNo++)).Instance(rowDuplicator).LifeStyle.Transient);
}
}
var missingForeignKeyHandlerNodeList = document.SelectNodes("ns:DataManipulators/ns:MissingForeignKeyHandler", namespaceManager);
if (missingForeignKeyHandlerNodeList != null && missingForeignKeyHandlerNodeList.Count > 0)
{
var missingForeignKeyHandlerNo = 0;
foreach (XmlNode missingForeignKeyHandlerNode in missingForeignKeyHandlerNodeList)
{
var workerNode = missingForeignKeyHandlerNode.SelectSingleNode("ns:PrimaryKeyAdder | ns:ForeignKeyCleaner | ns:ForeignKeyDeleter", namespaceManager);
if (workerNode == null)
{
continue;
}
var foreignKeyFields = new List <string>();
var foreignKeyFieldNodeList = workerNode.SelectNodes("ns:ForeignKey", namespaceManager);
if (foreignKeyFieldNodeList != null && foreignKeyFieldNodeList.Count > 0)
{
// ReSharper disable PossibleNullReferenceException
foreignKeyFields.AddRange(from XmlNode foreignKeyFieldNode in foreignKeyFieldNodeList select foreignKeyFieldNode.Attributes["field"].Value);
// ReSharper restore PossibleNullReferenceException
}
IMissingForeignKeyWorker worker = null;
switch (workerNode.LocalName)
{
case "PrimaryKeyAdder":
var setFieldValues = new Dictionary <string, object>();
var setFieldValueNodeList = workerNode.SelectNodes("ns:SetValue", namespaceManager);
if (setFieldValueNodeList != null && setFieldValueNodeList.Count > 0)
{
foreach (XmlNode setFieldValueNode in setFieldValueNodeList)
{
// ReSharper disable PossibleNullReferenceException
setFieldValues.Add(setFieldValueNode.Attributes["field"].Value, setFieldValueNode.Attributes["value"].Value);
// ReSharper restore PossibleNullReferenceException
}
}
try
{
// ReSharper disable PossibleNullReferenceException
worker = new PrimaryKeyAdder(workerNode.Attributes["targetTable"].Value, foreignKeyFields, setFieldValues, container.Resolve <IMetadataRepository>(), container.Resolve <IInformationLogger>());
// ReSharper restore PossibleNullReferenceException
}
catch (DeliveryEngineSystemException)
{
continue;
}
break;
case "ForeignKeyCleaner":
try
{
// ReSharper disable PossibleNullReferenceException
worker = new ForeignKeyCleaner(workerNode.Attributes["targetTable"].Value, foreignKeyFields, container.Resolve <IMetadataRepository>(), container.Resolve <IInformationLogger>());
// ReSharper restore PossibleNullReferenceException
}
catch (DeliveryEngineSystemException)
{
continue;
}
break;
case "ForeignKeyDeleter":
try
{
// ReSharper disable PossibleNullReferenceException
worker = new ForeignKeyDeleter(workerNode.Attributes["targetTable"].Value, foreignKeyFields, container.Resolve <IMetadataRepository>(), container.Resolve <IInformationLogger>());
// ReSharper restore PossibleNullReferenceException
}
catch (DeliveryEngineSystemException)
{
continue;
}
break;
}
// ReSharper disable PossibleNullReferenceException
var missingForeignKeHandler = new MissingForeignKeyHandler(missingForeignKeyHandlerNode.Attributes["table"].Value, worker, container.Resolve <IContainer>());
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IMissingForeignKeyHandler>().Named(string.Format("{0}[{1}]", typeof(IMissingForeignKeyHandler).Name, missingForeignKeyHandlerNo++)).Instance(missingForeignKeHandler).LifeStyle.Transient);
}
}
}
finally
{
reader.Close();
}
resourceStream.Close();
}
container.Register(Component.For <IDataManipulators>().ImplementedBy <DataManipulators>().LifeStyle.Transient);
}
