public void FindMatchesIdentifiesAttributesNotMatching()
{
var oldAttribute = Model.UsingModule <ConfigurationModule>().Create <IAttributeDefinition>();
var newAttribute = Model.UsingModule <ConfigurationModule>().Create <IAttributeDefinition>();
var oldMatchingAttribute = Model.UsingModule <ConfigurationModule>().Create <IAttributeDefinition>();
var oldAttributes = new[]
{
oldAttribute, oldMatchingAttribute
};
var newMatchingAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>()
.Set(x =>
{
x.Name = oldMatchingAttribute.Name;
x.Arguments = oldMatchingAttribute.Arguments;
});
var newAttributes = new[]
{
newMatchingAttribute, newAttribute
};
var sut = new AttributeEvaluator();
var results = sut.FindMatches(oldAttributes, newAttributes);
results.MatchingItems.Should().HaveCount(1);
results.MatchingItems.First().OldItem.Should().Be(oldMatchingAttribute);
results.MatchingItems.First().NewItem.Should().Be(newMatchingAttribute);
results.ItemsAdded.Should().HaveCount(1);
results.ItemsAdded.First().Should().Be(newAttribute);
results.ItemsRemoved.Should().HaveCount(1);
results.ItemsRemoved.First().Should().Be(oldAttribute);
}
public void GetRelatedAddendaTest()
{
// Arrange
var manager = new RelatedEntityExtensions <User, IUser, int>();
var evaluator = new AttributeEvaluator();
var mockClient = new Mock <IEntityClientAsync>();
mockClient.Setup(c => c.GetByCustomUrlAsync(It.IsAny <string>(), It.IsAny <Func <string, HttpContent, Task <HttpResponseMessage> > >(), It.IsAny <object>()))
.ReturnsAsync(AddendumTypeJson);
mockClient.Setup(c => c.EntityPluralized).Returns("Addenda");
mockClient.Setup(c => c.HttpClient).Returns(new HttpClient());
manager.ClientsCache.Json.Add("Addendum", mockClient.Object);
var user = new User {
Id = 1, UserTypeId = 2
};
var expandPaths = new List <ExpandPath>();
// Act
var actual = TaskRunner.RunSynchonously(manager.GetRelatedExtensionEntitiesAsync, new[] { user }, new[] { "Addendum" });
// Assert
Assert.AreEqual(1, actual.Count);
Assert.AreEqual("User", actual[0].Entity);
Assert.AreEqual("1", actual[0].EntityId);
Assert.AreEqual("Addendum", actual[0].RelatedEntity);
Assert.AreEqual(AddendumTypeJsonObject1, actual[0][0].Object.ToString());
Assert.AreEqual(AddendumTypeJsonObject2, actual[0][1].Object.ToString());
}
public void FindMatchesReturnsSingleAttributeMatchingByName(string firstName, string secondName, bool expected)
{
var oldAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>()
.Set(x => x.Name = firstName);
var oldAttributes = new[]
{
oldAttribute
};
var newAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>()
.Set(x => { x.Name = secondName; });
var newAttributes = new[]
{
newAttribute
};
var sut = new AttributeEvaluator();
var results = sut.FindMatches(oldAttributes, newAttributes);
if (expected)
{
results.MatchingItems.Should().HaveCount(1);
results.MatchingItems.First().OldItem.Should().Be(oldAttribute);
results.MatchingItems.First().NewItem.Should().Be(newAttribute);
results.ItemsAdded.Should().BeEmpty();
results.ItemsRemoved.Should().BeEmpty();
}
else
{
results.MatchingItems.Should().BeEmpty();
}
}
public void FindMatchesReturnsSingleAttributeMatchingByNameIgnoringAttributeSuffix()
{
var oldAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>()
.Set(x => x.Name = "SomethingAttribute");
var oldAttributes = new[]
{
oldAttribute
};
var newAttribute = Model.UsingModule <ConfigurationModule>().Create <TestAttributeDefinition>()
.Set(x => x.Name = "Something");
var newAttributes = new[]
{
newAttribute
};
var sut = new AttributeEvaluator();
var results = sut.FindMatches(oldAttributes, newAttributes);
results.MatchingItems.Should().HaveCount(1);
results.MatchingItems.First().OldItem.Should().Be(oldAttribute);
results.MatchingItems.First().NewItem.Should().Be(newAttribute);
results.ItemsAdded.Should().BeEmpty();
results.ItemsRemoved.Should().BeEmpty();
}
public void GetRelatedEntitiesTest()
{
// Arrange
var manager = new RelatedEntityManyToOne <User, IUser, int>();
var evaluator = new AttributeEvaluator();
var mockClient = new Mock <IEntityClientAsync>();
mockClient.Setup(c => c.GetByIdsAsync(It.IsAny <IEnumerable <string> >(), It.IsAny <string>())).ReturnsAsync(UserTypeJson);
manager.ClientsCache.Json.Add("UserType", mockClient.Object);
var user = new User {
Id = 1, UserTypeId = 2
};
var attributes = evaluator.GetAttributesToExpand(typeof(User), new[] { "UserType" });
var expandPaths = new List <ExpandPath>();
// Act
var actual = TaskRunner.RunSynchonously(manager.GetRelatedEntitiesAsync, new[] { user }, attributes, expandPaths);
// Assert
Assert.AreEqual(1, actual.Count);
Assert.AreEqual("User", actual[0].Entity);
Assert.AreEqual("1", actual[0].EntityId);
Assert.AreEqual("UserType", actual[0].RelatedEntity);
Assert.AreEqual(UserTypeJsonObject, actual[0][0].Object.ToString());
}
private void FormLoaded(object sender, EventArgs e)
{
looper = new frmLooper(this);
looper.TopMost = true;
Reload();
AttributeEvaluator evaluator = new AttributeEvaluator(new ProcessAction());
List <string> cols = evaluator.PropertiesByValueBool(true, typeof(MergableAttribute), "Mergable");
DgvMerger merger = new DgvMerger(dgItems, cols);
}
public void FindMatchesThrowsExceptionWithNullOldItems()
{
var newItems = Array.Empty <AttributeDefinition>();
var sut = new AttributeEvaluator();
Action action = () => sut.FindMatches(null !, newItems);
action.Should().Throw <ArgumentNullException>();
}
public async Task <List <RelatedEntityCollection> > GetRelatedEntitiesAsync(IEnumerable <TInterface> entities, IEnumerable <ExpandPath> expandPaths = null)
{
var list = new List <RelatedEntityCollection>();
var attributes = AttributeEvaluator.GetAttributesToExpand(typeof(TEntity), expandPaths?.Select(ep => ep.Entity));
var relatedEntities = await GetRelatedEntitiesAsync(entities, attributes, expandPaths);
if (relatedEntities != null && relatedEntities.Any())
{
list.AddRange(relatedEntities);
}
return(list);
}
public void GetAttributesToExpandNullNoAutoexpandTest()
{
// Arrange
List <string> entitiesToExpand = null;
var evaluator = new AttributeEvaluator();
// Act
var actual = evaluator.GetAttributesToExpand <RelatedEntityAttribute>(typeof(User), entitiesToExpand).ToList();
// Assert
Assert.AreEqual(0, actual.Count);
}
private void btnAdd_Click(object sender, EventArgs e)
{
bool x = new AttributeEvaluator(new ProcessAction()).Evaluate("PlannedFinish", typeof(MergableAttribute), "Mergable");
if (x)
{
MessageBox.Show("Wartość TRUE");
}
else
{
MessageBox.Show("Wartość FALSE");
}
}
public void GetAttributesToExpandNullAutoexpandTrueTest()
{
// Arrange
List <string> entitiesToExpand = null;
var evaluator = new AttributeEvaluator();
var expected = new RelatedEntityAttribute("User")
{
Property = "UserId", AutoExpand = true
};
// Act
var actual = evaluator.GetAttributesToExpand <RelatedEntityAttribute>(typeof(Token), entitiesToExpand).ToList();
// Assert
Assert.AreEqual(1, actual.Count);
foreach (var prop in typeof(RelatedEntityAttribute).GetProperties())
{
Assert.AreEqual(prop.GetValue(expected), prop.GetValue(actual[0]));
}
}
public async Task FindMatchesReturnsMatchesByArguments(string oldCode, string newCode,
bool expected, string scenario)
{
_output.WriteLine(scenario);
var oldNode = await TestNode
.FindNode <AttributeSyntax>(AttributeDefinitionCode.SimpleAttribute.Replace("SimpleAttribute", oldCode))
.ConfigureAwait(false);
var oldAttribute = new AttributeDefinition(oldNode);
var oldAttributes = new[]
{
oldAttribute
};
var newNode = await TestNode
.FindNode <AttributeSyntax>(AttributeDefinitionCode.SimpleAttribute.Replace("SimpleAttribute", newCode))
.ConfigureAwait(false);
var newAttribute = new AttributeDefinition(newNode);
var newAttributes = new[]
{
newAttribute
};
var sut = new AttributeEvaluator();
var results = sut.FindMatches(oldAttributes, newAttributes);
if (expected)
{
results.MatchingItems.Should().HaveCount(1);
results.MatchingItems.First().OldItem.Should().Be(oldAttribute);
results.MatchingItems.First().NewItem.Should().Be(newAttribute);
results.ItemsAdded.Should().BeEmpty();
results.ItemsRemoved.Should().BeEmpty();
}
else
{
results.MatchingItems.Should().BeEmpty();
}
}
private async Task <bool> LoadActions()
{
await _this.ProcessActions.GetByProcessId(_this.ProcessId);
if (_this.ProcessActions.Items.Any())
{
dgvActions.DataSource = _this.ProcessActions.Items;
//dgvActions.Columns["ProcessId"].Visible = false;
dgvActions.Columns["PlannedStart"].Visible = false;
dgvActions.Columns["PlannedFinish"].Visible = false;
dgvActions.Columns["PlaceName"].Visible = false;
AttributeEvaluator evaluator = new AttributeEvaluator(new ProcessAction());
List <string> cols = evaluator.PropertiesByValueBool(true, typeof(MergableAttribute), "Mergable");
DgvMerger merger = new DgvMerger(dgvActions, cols);
dgvActions.NullableBoolCheckbox(); //make bool? column a checkbox column
//Make "AbandonReason" column a combobox column
var cmbAbandonReason = new DataGridViewComboBoxColumn();
cmbAbandonReason.Name = "AbandonReason";
cmbAbandonReason.HeaderText = "Powód niewykonania";
cmbAbandonReason.DataSource = AbandonReasons.Items;
cmbAbandonReason.DisplayMember = "Name";
cmbAbandonReason.ValueMember = "AbandonReasonId";
cmbAbandonReason.DataPropertyName = "AbandonReasonId";
dgvActions.Columns.Insert(6, cmbAbandonReason);
foreach (DataGridViewColumn col in dgvActions.Columns)
{
col.ReadOnly = true;
}
return(true);
}
else
{
return(false);
}
}
public static IChangeCalculator BuildCalculator(ILogger?logger)
{
var attributeComparer = new AttributeComparer();
var attributeMatcher = new AttributeEvaluator();
var attributeProcessor = new AttributeMatchProcessor(attributeMatcher, attributeComparer, logger);
var accessModifierChangeTable = new AccessModifiersChangeTable();
var accessModifiersComparer = new AccessModifiersComparer(accessModifierChangeTable);
var memberModifiersChangeTable = new PropertyModifiersChangeTable();
var memberModifiersComparer = new PropertyModifiersComparer(memberModifiersChangeTable);
var genericTypeElementComparer = new GenericTypeElementComparer();
var fieldModifiersChangeTable = new FieldModifiersChangeTable();
var fieldModifiersComparer = new FieldModifiersComparer(fieldModifiersChangeTable);
var fieldComparer = new FieldComparer(accessModifiersComparer, fieldModifiersComparer, attributeProcessor);
var fieldMatcher = new FieldEvaluator();
var fieldProcessor = new FieldMatchProcessor(fieldMatcher, fieldComparer, logger);
var propertyAccessorAccessModifiersChangeTable = new PropertyAccessorAccessModifiersChangeTable();
var propertyAccessorAccessModifiersComparer = new PropertyAccessorAccessModifiersComparer(propertyAccessorAccessModifiersChangeTable);
var propertyAccessorComparer = new PropertyAccessorComparer(propertyAccessorAccessModifiersComparer, attributeProcessor);
var propertyAccessorEvaluator = new PropertyAccessorEvaluator();
var propertyAccessorProcessor =
new PropertyAccessorMatchProcessor(propertyAccessorEvaluator, propertyAccessorComparer, logger);
var propertyComparer = new PropertyComparer(accessModifiersComparer, memberModifiersComparer, propertyAccessorProcessor, attributeProcessor);
var propertyMatcher = new PropertyEvaluator();
var propertyProcessor = new PropertyMatchProcessor(propertyMatcher, propertyComparer, logger);
var methodEvaluator = new MethodEvaluator();
var methodModifiersChangeTable = new MethodModifiersChangeTable();
var methodModifiersComparer = new MethodModifiersComparer(methodModifiersChangeTable);
var parameterModifiersChangeTable = new ParameterModifiersChangeTable();
var parameterModifiersComparer = new ParameterModifiersComparer(parameterModifiersChangeTable);
var parameterComparer = new ParameterComparer(parameterModifiersComparer, attributeProcessor);
var methodComparer = new MethodComparer(accessModifiersComparer, methodModifiersComparer, genericTypeElementComparer, parameterComparer, attributeProcessor);
var methodProcessor = new MethodMatchProcessor(methodEvaluator, methodComparer, logger);
var classModifiersChangeTable = new ClassModifiersChangeTable();
var classModifiersComparer = new ClassModifiersComparer(classModifiersChangeTable);
var classComparer = new ClassComparer(
accessModifiersComparer,
classModifiersComparer,
genericTypeElementComparer,
fieldProcessor,
propertyProcessor,
methodProcessor, attributeProcessor);
var interfaceComparer = new InterfaceComparer(
accessModifiersComparer,
genericTypeElementComparer,
propertyProcessor,
methodProcessor,
attributeProcessor);
var structModifiersChangeTable = new StructModifiersChangeTable();
var structModifiersComparer = new StructModifiersComparer(structModifiersChangeTable);
var structComparer = new StructComparer(
accessModifiersComparer,
structModifiersComparer,
genericTypeElementComparer,
fieldProcessor,
propertyProcessor,
methodProcessor,
attributeProcessor);
var aggregateTypeComparer = new AggregateTypeComparer(classComparer, interfaceComparer, structComparer);
var typeEvaluator = new TypeEvaluator();
var typeProcessor = new TypeMatchProcessor(typeEvaluator, aggregateTypeComparer, logger);
return(new ChangeCalculator(typeProcessor, logger));
}
