public void Can_create_entity_wrapper()
{
var service = Substitute.For <IOrganizationService>();
var context = Substitute.For <ITransactionContextBase>();
context.Service.Returns(service);
var entity = new Entity("xts_nongenericentity")
{
Id = Guid.NewGuid()
};
var xtsEntity = new xts_entity {
Id = Guid.NewGuid()
};
InstanceEntityWrapper <Entity, TestWrapper> .Create(entity, context);
InstanceEntityWrapper <xts_entity, TestGenericWrapper <xts_entity> > .Create(xtsEntity, context);
InstanceEntityWrapper <xts_entity, EntityWrapper <xts_entity> > .Create(xtsEntity, context);
InstanceEntityWrapper <Entity, TestWrapper> .Create(xtsEntity, context);
var accessor = new EntityAccessor <Entity>(entity);
InstanceEntityWrapper <Entity, TestWrapper> .Create(accessor, context);
var xtsAccessor = new EntityAccessor <xts_entity>(xtsEntity);
InstanceEntityWrapper <xts_entity, TestGenericWrapper <xts_entity> > .Create(xtsAccessor, context);
InstanceEntityWrapper <xts_entity, EntityWrapper <xts_entity> > .Create(xtsAccessor, context);
InstanceEntityWrapper <Entity, TestWrapper> .Create(xtsAccessor, context);
}
public void Can_execute_command_methods()
{
var test = new TestHelper();
var related = new xts_relatedentity {
Id = Guid.NewGuid()
};
related.Set(e => e.xts_name, "RELATED");
var reference = new xts_entity {
Id = Guid.NewGuid()
};
reference.Set(e => e.xts_optionsetvalue, 12);
reference.Set(e => e.xts_int, 345);
reference.Set(e => e.xts_string, "PARENT");
reference.Set(e => e.xts_referenceid, related.ToEntityReference());
reference.Set(e => e.xts_money, new Money(1234m));
reference.SetFormattedValue(e => e.xts_attribute, "Hello Formatted Value");
reference.SetFormattedValue("xts_anotherattribute", "1234-another-fv");
var child = new xts_relatedentity {
Id = Guid.NewGuid()
};
child.Set(e => e.xts_name, "CHILD");
child.Set(e => e.xts_relatedid, reference.ToEntityReference());
test.Service.Retrieve(Arg.Any <string>(), Arg.Is <Guid>(id => id == related.Id), Arg.Any <ColumnSet>())
.Returns(related);
test.Service.Retrieve(Arg.Any <string>(), Arg.Is <Guid>(id => id == child.Id), Arg.Any <ColumnSet>())
.Returns(child);
test.Service.RetrieveMultiple(Arg.Any <QueryBase>()).Returns(new EntityCollection(new List <Entity> {
child
}));
var context = Substitute.For <ITransactionContext <xts_entity> >();
context.Service.Returns(test.Service);
var txReference = new TransactionContextEntity <xts_entity>(reference);
context.Current.Returns(txReference);
var commandTest = new CommandTest(context);
commandTest.ExecuteTest();
IEntityWrapperRelation <xts_entity> wrapper = commandTest;
var relatedColumnSet = new ColumnSet <xts_relatedentity>(
e => e.Id,
e => e.xts_name
);
var relatedGeneric = wrapper.GetRelated(e => e.xts_referenceid, relatedColumnSet);
Assert.Equal("RELATED", relatedGeneric.Get(e => e.xts_name));
}
public void Can_access_initial_data()
{
var test = new TestHelper();
var input = new xts_entity
{
Id = Guid.NewGuid()
};
var dbEntity = new xts_entity
{
Id = input.Id
};
dbEntity.Set(e => e.xts_string, "1234");
dbEntity.FormattedValues["xts_optionsetvalue"] = "Hello";
test.Service.Retrieve(Arg.Any <string>(), Arg.Any <Guid>(), Arg.Any <ColumnSet>())
.Returns(dbEntity);
test.PluginExecutionContext.MessageName.Returns(PluginMessage.Update);
test.PluginExecutionContext.InputParameters["Target"] = input.ToEntity <Entity>();
var plugin = Substitute.For <IPluginBase>();
var container = Substitute.For <IContainer>();
var config = new PluginConfiguration <xts_entity>(plugin, container)
{
ColumnSet = new ColumnSet <xts_entity>(e => e.xts_string, e => e.xts_optionsetvalue)
};
ITransactionContext <xts_entity> context = new TransactionContext <xts_entity>(test.ServiceProvider, config);
Assert.Equal("Hello", context.Initial.GetFormattedValue("xts_optionsetvalue"));
}
public void Can_convert_to_derived_wrapper()
{
var entity = new xts_entity
{
Id = Guid.NewGuid()
};
var reference = new EntityReference("reference", Guid.NewGuid());
entity[Helper.Name <xts_derivedentity>(e => e.xts_derivedattribute)] = reference;
var service = Substitute.For <IOrganizationService>();
var context = Substitute.For <ITransactionContextBase>();
context.Service.Returns(service);
var entityWrapper = new EntityWrapper <xts_entity>(entity, context);
var testWrapper = entityWrapper.ToWrapper <xts_entity, ConvertTestWrapper <xts_entity> >();
var derivedWrapper = testWrapper.ToWrapper <xts_derivedentity, ConvertDerivedTestWrapper <xts_derivedentity> >();
Assert.Equal(reference, derivedWrapper.Entity.GetAttributeValue <EntityReference>("xts_derivedattribute"));
var sameDerivedWrapper = derivedWrapper.ToWrapper <xts_derivedentity, ConvertDerivedTestWrapper <xts_derivedentity> >();
Assert.Same(derivedWrapper, sameDerivedWrapper);
}
public void Can_get_name()
{
var test = new TestHelper();
var keyEntity = new xts_keytest {
Id = Guid.NewGuid()
};
keyEntity.Set(e => e.xts_key, "Hello world");
test.Service.Retrieve(Arg.Is <string>(name => name == "xts_keytest"), Arg.Any <Guid>(), Arg.Any <ColumnSet>())
.Returns(keyEntity);
var entity = new xts_entity {
Id = Guid.NewGuid()
};
entity.Set(e => e.xts_referenceid, keyEntity.ToEntityReference());
var context = Substitute.For <ITransactionContext <xts_entity> >();
context.Service.Returns(test.Service);
context.Current.Returns(new TransactionContextEntity <xts_entity>(entity));
var command = new CommandTest(context);
Assert.Equal("Hello world", command.GetNameTest <xts_keytest>(e => e.xts_referenceid));
}
public void Can_execute_methods_in_operation_base()
{
var reference = new xts_entity {
Id = Guid.NewGuid()
};
var context = Substitute.For <ITransactionContext <xts_entity> >();
var txReference = new TransactionContextEntity <xts_entity>(reference);
context.Target.Returns(txReference);
context.Current.Returns(txReference);
new MethodOperation(context).Execute();
var input = context.Target;
Assert.Equal(1234m, input.Get(e => e.xts_money).Value);
Assert.Equal(3000m, input.Get(e => e.xts_othermoney).Value);
Assert.Equal(11, input.Get(e => e.xts_optionsetvalue).Value);
Assert.Equal(45, input.Get(e => e.xts_otheroptionsetvalue).Value);
Assert.Equal("HELLO", input.Get(e => e.xts_string));
Assert.Equal(77, input.Get(e => e.xts_int));
Assert.Equal(566f, input.Get(e => e.xts_float));
Assert.Equal(88, input.Get(e => e.xts_otherint));
Assert.Equal("WORLD", input.Get(e => e.xts_otherstring));
Assert.Equal(7890m, input.Get(e => e.xts_totalmoney).Value);
}
public void Change_on_entity_reference(EntityReference from, EntityReference to, bool expected)
{
var expectedFrom = new EntityReference("entity", new Guid("e6ed2acb-8f66-44c9-847b-5897a2120147"));
var expectedTo = new EntityReference("entity", new Guid("c78e077f-81d1-4791-853c-257e47580c86"));
var test = new TestHelper();
var id = Guid.NewGuid();
var initial = new xts_entity {
Id = id
};
initial.Set(e => e.xts_attribute, expectedFrom);
var reference = new xts_entity {
Id = id
};
reference.Set(e => e.xts_attribute, expectedTo);
var context = Substitute.For <ITransactionContext <xts_entity> >();
context.Initial.Returns(initial.ToEntityAccessor());
context.Current.Returns(new TransactionContextEntity <xts_entity>(reference));
var command = new CommandTest(context);
var actual = command.ChangeTest(e => e.xts_attribute, from, to);
Assert.Equal(expected, actual);
actual = command.ChangeTest("xts_attribute", from, to);
Assert.Equal(expected, actual);
}
public void Change_on_option_set_value_enum(CommandEnumTest?from, CommandEnumTest?to, bool expected)
{
var test = new TestHelper();
var id = Guid.NewGuid();
var initial = new xts_entity {
Id = id
};
initial.Set(e => e.xts_optionsetvalue, CommandEnumTest.Eleven);
var reference = new xts_entity {
Id = id
};
reference.Set(e => e.xts_optionsetvalue, CommandEnumTest.Thirteen);
var context = Substitute.For <ITransactionContext <xts_entity> >();
context.Initial.Returns(initial.ToEntityAccessor());
context.Current.Returns(new TransactionContextEntity <xts_entity>(reference));
var command = new CommandTest(context);
var actual = command.ChangeTest(e => e.xts_optionsetvalue, from, to);
Assert.Equal(expected, actual);
}
public void Change_on_money_decimal(decimal?from, decimal?to, bool expected)
{
var test = new TestHelper();
var id = Guid.NewGuid();
var initial = new xts_entity {
Id = id
};
initial.Set(e => e.xts_money, 100m);
var reference = new xts_entity {
Id = id
};
reference.Set(e => e.xts_money, 250m);
var context = Substitute.For <ITransactionContext <xts_entity> >();
context.Initial.Returns(initial.ToEntityAccessor());
context.Current.Returns(new TransactionContextEntity <xts_entity>(reference));
var command = new CommandTest(context);
var actual = command.ChangeTest(e => e.xts_money, from, to);
Assert.Equal(expected, actual);
}
public void Can_get_name()
{
var keyEntity = new xts_keytest {
Id = Guid.NewGuid()
};
keyEntity.Set(e => e.xts_key, "Hello world");
var service = Substitute.For <IOrganizationService>();
service.Retrieve(Arg.Is <string>(name => name == "xts_keytest"), Arg.Any <Guid>(), Arg.Any <ColumnSet>())
.Returns(keyEntity);
var context = Substitute.For <ITransactionContextBase>();
context.Service.Returns(service);
var entity = new xts_entity {
Id = Guid.NewGuid()
};
entity.Set(e => e.xts_referenceid, keyEntity.ToEntityReference());
var wrapper = new EntityWrapper <xts_entity>(entity, context);
Assert.Equal("Hello world", wrapper.GetReferenceName <xts_keytest>(e => e.xts_referenceid));
}
public void Entity_object_is_same()
{
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var txEntity = new TransactionContextEntity <xts_entity>(entity);
Assert.Same(entity, txEntity.Entity);
}
public void Can_set_option_set_value_using_enum()
{
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var txEntity = new TransactionContextEntity <xts_entity>(entity);
txEntity.Set(e => e.xts_optionsetvalue, TestOptions.SomeValue);
Assert.Equal(47, entity.Get(e => e.xts_optionsetvalue).Value);
}
public void Can_set_to_attribute()
{
var date = DateTime.UtcNow;
var provider = Substitute.For <ValueProviderBase <DateTime?> >();
provider.GetValue().Returns(date);
var entity = new xts_entity();
entity.Set(e => e.xts_datetime, provider);
Assert.Equal(date, entity.Get(e => e.xts_datetime));
}
public void Can_set_money_using_decimal()
{
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var txEntity = new TransactionContextEntity <xts_entity>(entity);
txEntity.Set(e => e.xts_money, 1234);
Assert.Equal(1234m, entity.Get(e => e.xts_money).Value);
}
public void Can_get_set_value()
{
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var txEntity = new TransactionContextEntity <xts_entity>(entity);
var reference = new EntityReference("reference", Guid.NewGuid());
txEntity.Set(e => e.xts_attribute, reference);
Assert.Equal(reference, entity.GetAttributeValue <EntityReference>("xts_attribute"));
Assert.Equal(reference, txEntity.Get(e => e.xts_attribute));
}
public void Can_get_correct_value()
{
var entity = new xts_entity();
var provider = Substitute.For <ValueProviderBase <xts_entity> >();
provider.GetValue().Returns(entity);
IValueProvider <xts_entity> interfaceStrongTypeProvider = provider;
IValueProvider interfaceProvider = provider;
Assert.Same(entity, provider.GetValue());
Assert.Same(entity, interfaceStrongTypeProvider.GetValue());
Assert.Same(entity, interfaceProvider.GetValue());
}
public void Can_access_wrapper_generic(string message, int stage)
{
var pluginContext = Substitute.For <IPluginExecutionContext>();
pluginContext.MessageName.Returns(message);
pluginContext.Stage.Returns(stage);
var referenceEntity = new xts_entity {
Id = Guid.NewGuid()
};
var reference = new TransactionContextEntity <xts_entity>(referenceEntity);
var context = Substitute.For <ITransactionContext <xts_entity> >();
context.PluginExecutionContext.Returns(pluginContext);
context.Current.Returns(reference);
Assert.Equal(referenceEntity.ToEntityReference(), ((ITransactionContext <Entity>)context).Current.Entity.ToEntityReference());
var operation = new WrapperOperation(context);
Assert.Equal(referenceEntity.ToEntityReference(), operation.PublicWrapper.Entity.ToEntityReference());
}
public void Can_use_extensions()
{
var derived = new xts_derivedentity {
Id = Guid.NewGuid()
};
derived.Set(e => e.xts_string, "Hello world");
var related = new xts_relatedentity {
Id = Guid.NewGuid()
};
related.Set(e => e.xts_relatedid, derived.ToEntityReference());
var service = Substitute.For <IOrganizationService>();
service.Retrieve(Arg.Any <string>(), Arg.Is <Guid>(id => id == derived.Id), Arg.Any <ColumnSet>())
.Returns(derived);
service.Retrieve(Arg.Any <string>(), Arg.Is <Guid>(id => id == related.Id), Arg.Any <ColumnSet>())
.Returns(related);
var entity = new xts_entity {
Id = Guid.NewGuid()
};
entity.Set(e => e.xts_referenceid, related.ToEntityReference());
var context = Substitute.For <ITransactionContextBase>();
context.Service.Returns(service);
var wrapper = new EntityWrapper <xts_entity>(entity, context);
var text = wrapper
.GetReference(new ColumnSet <xts_relatedentity>(e => e.xts_relatedid))
.GetProduct(new ColumnSet <xts_derivedentity>(e => e.xts_string))
.Get(e => e.xts_string);
Assert.Equal("Hello world", text);
}
public void Can_create_command_generic()
{
var context = Substitute.For <ITransactionContext <xts_entity> >();
var reference = new xts_entity {
Id = Guid.NewGuid()
};
var txReference = new TransactionContextEntity <xts_entity>(reference);
context.Current.Returns(txReference);
Assert.Same(reference, context.Current.Entity);
var input = new xts_entity {
Id = reference.Id
};
var txInput = new TransactionContextEntity <xts_entity>(input);
context.Target.Returns(txInput);
var command = new CommandGeneric(context);
Assert.NotNull(command.PublicWrapper);
Assert.Same(reference, command.PublicWrapper.Entity);
}
