public void ShouldParseSheetUsingClosedXML()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddWorksheetParser <FakeClass>(x => x.WithParser <ClosedXmlParser <FakeClass> >().WithMap <MyWorksheetMap>());
var serviceProvider = serviceCollection.BuildServiceProvider();
var expectedItens = new List <FakeClass>();
for (var i = 0; i < 5; i++)
{
expectedItens.Add(FakeClass.CreateItem(i % 2 == 0, i % 5 == 0));
}
var parser = serviceProvider.GetService <WorksheetParser <FakeClass> >();
var headers = new MyWorksheetMap().GetFields().Select(s => s.Name).ToList();
using var worksheet = CreateStream(expectedItens, headers);
var itens = parser.Parse(worksheet, worksheetName);
expectedItens.ForEach(x => x.Bonus = x.Bonus * 0.1M);
var validationResult = new ValidationResult <FakeClass>();
validationResult.AddItem(expectedItens);
itens.Should().BeEquivalentTo(validationResult);
}
public void ShouldReturnErrorsUsingClosedXMLAndCustomMessages()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddWorksheetParser <FakeClass>(x => x.WithParser <ClosedXmlParser <FakeClass> >().WithMap <MyWorksheetMap>().WithMessages <CustomMessages>());
var serviceProvider = serviceCollection.BuildServiceProvider();
var expectedItens = new List <FakeClass>
{
FakeClass.CreateItem(),
FakeClass.CreateItem(false, false, false),
FakeClass.CreateItem(false, false, true)
};
var parser = serviceProvider.GetService <WorksheetParser <FakeClass> >();
expectedItens.ForEach(x => x.Bonus *= 0.1M);
var validationResult = new ValidationResult <FakeClass>();
var error = new Error("Can't not be null field TX_NAME", 3, 2);
validationResult.AddError(error);
validationResult.AddItem(expectedItens.First());
validationResult.AddItem(expectedItens.Last());
var headers = new MyWorksheetMap().GetFields().Select(s => s.Name).ToList();
using var worksheet = CreateStream(expectedItens, headers);
var itens = parser.Parse(worksheet, worksheetName);
itens.Should().BeEquivalentTo(validationResult);
}
public void Arrange()
{
// arrange
FakeClass f = new FakeClass("sad");
b = new Bog();
}
public void Should_set_subobj_property_subobj_is_class_and_readwrite()
{
var fake = new FakeClass {
Name = "Empty"
};
var view = new ViewHasSubProps
{
FakeRef = fake
};
var page = new ContentPage
{
Content = view
};
var ctx = new XenMessageContext();
ctx.SetRequest <SetPropertyRequest>(r =>
{
r.WidgetId = view.Id.ToString();
r.Path = new [] { "FakeRef", "Name" };
r.Value = "New Value";
});
Assert.AreEqual("Empty", fake.Name);
XamarinFormsReaction.Register <SetPropertyRequest, SetPropertyReaction>(page);
Reaction.Execute(ctx);
Assert.AreEqual("New Value", fake.Name);
}
public void BuildXsltExtensionTest()
{
var factory = new XsltExtensionFactory();
var toWrap = new FakeClass();
var wrapped = factory.BuildXsltExtension(toWrap);
var wrappedType = wrapped.GetType();
{
var mi = wrappedType.GetMethod("do-work", BindingFlags.Public | BindingFlags.Instance);
var ret = mi?.Invoke(wrapped, new object[] { "Hi!" });
this.TestContext.WriteLine($"{"do-work"}: {ret}");
}
{
var mi = wrappedType.GetMethod("big-work", BindingFlags.Public | BindingFlags.Instance);
var ret = mi?.Invoke(wrapped, new object[] { "Hi!", "2", "3", "4", "5", "6" });
this.TestContext.WriteLine($"{"big-work"}: {ret}");
}
{
var mi = wrappedType.GetMethod("more-work", BindingFlags.Public | BindingFlags.Instance);
var ret = mi?.Invoke(wrapped, new object[] { "Hi!" });
this.TestContext.WriteLine($"{"more-work"}: {ret}");
}
{
var mi = wrappedType.GetMethod("other-work", BindingFlags.Public | BindingFlags.Instance);
var ret = mi?.Invoke(wrapped, Array.Empty <object>());
this.TestContext.WriteLine($"{"other-work"}: {ret}");
}
{
var mi = wrappedType.GetMethod("and-work", BindingFlags.Public | BindingFlags.Instance);
var ret = mi?.Invoke(wrapped, Array.Empty <object>());
this.TestContext.WriteLine($"{"and-work"}: {ret}");
}
}
public void MapperToOtherType()
{
var source = new FakeClass();
source.Id = Guid.NewGuid();
source.InnerClasses = new List <FakeClass.InnerClass>();
for (int i = 0; i < 5; i++)
{
source.InnerClasses.Add(new FakeClass.InnerClass {
InnerClassGuid = Guid.NewGuid()
});
}
var target = TinyMapper.Map <FakeClassDto>(source);
Assert.AreNotSame(source, target);
Assert.AreEqual(source.Id, target.Id);
Assert.AreEqual(source.InnerClasses.Count, target.InnerClasses.Count);
for (int i = 0; i < source.InnerClasses.Count; i++)
{
Assert.AreEqual(source.InnerClasses[i].InnerClassGuid, target.InnerClasses[i].InnerClassGuid);
}
}
static void Main(string[] args)
{
FakeClass.MyCostA = 123;
var x = FakeClass.CompareCosts(FakeClass.MyCostA);
Console.WriteLine(x);
Console.ReadKey();
}
public void Set_set_correct_value(int value)
{
var source = new FakeClass();
var target = GetPropertyAccessorFor("Available2");
target.Set(source,value);
source.Available2.Should().Be(value);
}
public void Given_InvalidType_ValidateLoggerType_ShouldReturn_False()
{
var logger = new FakeClass();
var result = LoggerTypeValidator.ValidateLoggerType(logger);
result.Should().BeFalse();
}
public void SaveDependant(string jsonEmp, string firstName, string lastName, string connId)
{
var emp = JsonConvert.DeserializeObject <Employee>(jsonEmp);
FakeClass.AddDependant(emp, firstName, lastName);
Clients.Client(connId).addOrUpdateEmployee(emp);
Clients.All.updateAllEmployees(FakeClass.GetAllEmployees());
}
public void AddOrUpdateEmployee(string jsonEmp, string connId)
{
var emp = JsonConvert.DeserializeObject <Employee>(jsonEmp);
emp = FakeClass.AddOrUpdateEmployee(emp);
Clients.Client(connId).addOrUpdateEmployee(emp);
Clients.All.updateAllEmployees(FakeClass.GetAllEmployees());
}
public void Add_ObjectWithKeyExistsButOverrideExistingValueIsTrue_ExceptionNotThrown()
{
//arrange
var myObject = new FakeClass();
_collection.Add("MyKey", myObject, true);
//act
_collection.Add("MyKey", new FakeClass(), true);
}
public void Add_ObjectWithKeyAlreadyAdded_ExceptionThrown()
{
//arrange
var myObject = new FakeClass();
_collection.Add("MyKey", myObject);
//act
_collection.Add("MyKey", new FakeClass());
}
public void Get_returns_correct_result(int value)
{
var source = new FakeClass
{
Available2 = value
};
var target = GetPropertyAccessorFor("Available2");
target.Get(source).Should().Be(value);
}
public TArgument GenericMethodRef <TArgument>(ref TArgument value) where TArgument : FakeClass
{
var result = new FakeClass()
{
Value = value.Value
};
value.Value++;
return((TArgument)result);
}
public ActionResult Edit(int id)
{
var model = FakeClass.GetEmployeeById(id);
if (model == null)
{
RedirectToAction("Index");
return(null);
}
return(RedirectToAction("EditEmployee", model));
}
public void Get_ObjectWithKeyMyKeyAdded_ReturnValueIsObject()
{
//arrange
var myObject = new FakeClass();
_collection.Add("MyKey", myObject);
//act
var returnValue = _collection.Get("MyKey");
//assert
Assert.AreEqual(myObject, returnValue);
}
public void Navigate_generic_context_uses_resolution_key_from_context_route_when_provided(string route, string routeWithoutKey, string resolutionKey)
{
var newViewModel = new FakeClass();
_ServiceLocator.GetInstance <FakeClass>(resolutionKey).Returns(newViewModel);
_RouterSolver.SolveRoute(newViewModel).Returns(route);
SetupRouteFromType(routeWithoutKey);
_NavigationViewModel.Navigate(new NavigationContext <FakeClass> {
ResolutionKey = resolutionKey
});
_NavigationViewModel.Route.Should().Be(route);
}
public void Get_ObjectWithKeyExistsButOverrideExistingValueIsTrue_NewestObjectReturned()
{
//arrange
var myObject = new FakeClass();
var newObject = new FakeClass();
_collection.Add("MyKey", myObject, true);
_collection.Add("MyKey", newObject, true);
//act
var returnValue = _collection.Get("MyKey");
//assert
Assert.AreEqual(newObject, returnValue);
}
public void FromClassInstanceToRavenDBAndBack()
{
IndexCreation.CreateIndexes(typeof(FakeClassIndex).Assembly, DependencyResolver.Current.GetService <IDocumentStore>());
var fakeClassInstance = new FakeClass
{
Age = 1,
Date = new DateTime(2012, 12, 12, 12, 12, 12),
Name = "Maxime Séguin"
};
using (var reflectionContentManager = DependencyResolver.Current.GetService <IReflectionContentManager>())
{
//TODO: Pas certain d'aimer que pour avoir un Content ça génère une query...
var content = reflectionContentManager.GetNewOrUpdatedContent(fakeClassInstance).Item;
reflectionContentManager.Store(content);
reflectionContentManager.SaveChanges();
}
RavenDBUtilities.WaitForStaleIndexes(DependencyResolver.Current.GetService <IDocumentStore>());
List <ContentTranslationVersion> contents;
using (var session = DependencyResolver.Current.GetService <IDocumentSession>())
{
contents = session.Query <Content, FakeClassIndex>()
.AsProjection <ContentTranslationVersion>()
.ToList();
}
Assert.That(contents.Count, Is.EqualTo(1));
List <FakeClass> fakeClasses;
using (var session = DependencyResolver.Current.GetService <IDocumentSession>())
{
fakeClasses = session.Query <Content, FakeClassIndex>()
.AsProjection <FakeClass>()
.ToList();
}
Assert.That(fakeClasses.Count, Is.EqualTo(1));
var savedFakeClassInstance = fakeClasses.ElementAt(0);
Assert.That(savedFakeClassInstance.Age, Is.EqualTo(fakeClassInstance.Age));
Assert.That(savedFakeClassInstance.Date, Is.EqualTo(fakeClassInstance.Date));
Assert.That(savedFakeClassInstance.Name, Is.EqualTo(fakeClassInstance.Name));
}
public void TestProcessOrder()
{
var fakeClass = new FakeClass();
fakeClass.SetProductionInfo(new ProductInfo {
ProductId = 1, Price = 123
},
new ProductInfo {
ProductId = 2, Price = 634
},
new ProductInfo {
ProductId = 3, Price = 200
},
new ProductInfo {
ProductId = 4, Price = 150
});
var processOrder = fakeClass.ProcessOrder(new PaymentInfo
{
UserId = 123,
Detail = new List <PaymentDetail>
{
new PaymentDetail
{
ProdId = 1,
Count = 2
},
new PaymentDetail
{
ProdId = 2,
Count = 3
},
new PaymentDetail
{
ProdId = 4,
Count = 1
}
}
});
new { UserId = 123, OrderAmount = 2298M }.ToExpectedObject().ShouldMatch(processOrder.order);
new[]
{
new { ProductId = 1, Amount = 246M },
new { ProductId = 2, Amount = 1902M },
new { ProductId = 4, Amount = 150M },
}.ToExpectedObject().ShouldMatch(processOrder.orderDetailList);
}
public NavigationViewModelTests()
{
_ExpectedNewViewModel = new FakeClass();
_ExpectedRedirectViewModel = new SecondFakeClass();
_ServiceLocator = Substitute.For <IServiceLocator>();
_ServiceLocator.GetInstance(_FakeType).Returns(_ExpectedNewViewModel);
_ServiceLocator.GetInstance <FakeClass>().Returns(_ExpectedNewViewModel);
_ServiceLocator.GetInstance(_FakeTypeRedirect).Returns(_ExpectedRedirectViewModel);
_ServiceLocator.GetInstance(null).Throws(new ArgumentNullException("serviceType"));
_RouterSolver = Substitute.For <IRouterSolver>();
_RouterSolver.SolveType(null).Throws <Exception>();
_RouterSolver.SolveRoute(Arg.Any <object>()).Returns(default(string));
_NavigationViewModel = new NavigationViewModel(new Lazy <IServiceLocator>(() => _ServiceLocator),
_RouterSolver, _OriginalRoute);
}
public void HasFieldsWithSameValueShouldProcessNullFields()
{
var instance1 = new FakeClass()
{
Items = new List <string>()
};
var instance2 = new FakeClass();
Check.ThatCode(() =>
{
Check.That(instance2).HasFieldsWithSameValues(instance1); // throws NullReferenceException
Check.That(instance1).HasFieldsWithSameValues(instance2); // throws FluentCheckException
throw new Exception("Checks should fail.");
}).IsAFaillingCheck();
}
public void CreateProperty_MultipleProperties_AreReturned()
{
// arrange
var settings = GetSettings("property1, property2");
var testObj = new FakeClass {
Property1 = "prop1", Property2 = "prop2"
};
// act
var result = JsonConvert.SerializeObject(testObj, Formatting.None, settings);
var reversed = JsonConvert.DeserializeObject <FakeClass>(result);
// assert
Assert.NotNull(reversed.Property1);
Assert.NotNull(reversed.Property2);
}
public void CreateProperty_SingleProperty_IsReturned()
{
// arrange
var settings = GetSettings("property1");
var testObj = new FakeClass {
Property1 = "prop1", Property2 = "prop2"
};
// act
var result = JsonConvert.SerializeObject(testObj, Formatting.None, settings);
var reversed = JsonConvert.DeserializeObject <FakeClass>(result);
// assert
Assert.NotNull(reversed.Property1);
Assert.Null(reversed.Property2); // should be null since it wasn't included in the original serialization
}
public void WithConcreteObjectMapping_GivenTypeAndConcreteObjectMapping_ShouldAddMappingToContainer()
{
//---------------Set up test pack-------------------
var fakeClass = new FakeClass();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var bootstrapper = StructuremapThuriaBootstrapper.Create()
.WithConcreteObjectMapping(typeof(IFakeInterface), fakeClass)
.Build();
//---------------Test Result -----------------------
var foundClass = bootstrapper.IocContainer.GetInstance <IFakeInterface>();
foundClass.Should().NotBeNull();
foundClass.Should().BeAssignableTo <IFakeInterface>();
foundClass.Should().BeAssignableTo <FakeClass>();
}
public void DeleteElement_With_ValidFakeClassValue_Returns_NewMinValue()
{
//Arrange
var heap = new BinaryHeap <FakeClass>(fakeElements);
var valueForChanged = fakeElements[0];
var newValue = new FakeClass()
{
Value = int.MinValue
};
//Act
heap.DecreaseKey(valueForChanged, newValue);
var newMin = heap.GetMin;
//Assert
Assert.AreEqual(newValue, newMin);
}
public void TestUpdateShouldSerializeMaybeField()
{
MaybeContractResolverWrapper testWrapper = new MaybeContractResolverWrapper();
JsonProperty property = new JsonProperty
{
PropertyType = typeof(Maybe <string>),
PropertyName = nameof(FakeClass.Name)
};
FakeClass fc = new FakeClass
{
Name = "test"
};
Assert.IsNotNull(testWrapper.TestUpdateShouldSerialize(property));
Assert.IsTrue(property.ShouldSerialize(fc));
}
public void TestUpdateShouldSerializeMaybeProtectedField()
{
MaybeContractResolverWrapper testWrapper = new MaybeContractResolverWrapper();
JsonProperty property = new JsonProperty
{
PropertyType = typeof(Maybe <float>),
PropertyName = "Price"
};
FakeClass fc = new FakeClass
{
Name = "test"
};
Assert.IsNotNull(testWrapper.TestUpdateShouldSerialize(property));
Assert.IsFalse(property.ShouldSerialize(fc));
}
public void InitializeShouldRegisterCustomFactories()
{
FakeClass fakeInstance = new FakeClass();
ITypeFactory factory = Substitute.For <ITypeFactory>();
factory.CanCreate(typeof(IFakeInterface))
.Returns(true);
factory.Create(typeof(IFakeInterface), Arg.Any <IServiceProvider>())
.Returns(fakeInstance);
this.bootstrapper.DiscoveryService.GetCustomFactories()
.Returns(new[] { factory });
this.bootstrapper.Initialize();
object instance = this.bootstrapper.OriginalProvider.GetService(typeof(IFakeInterface));
Assert.That(instance, Is.SameAs(fakeInstance));
}
public void ShouldConstructTheObjectWithTheFactoryDelegate()
{
bool delegateCalled = false;
FakeClass.ClearConstructorCount();
RouteMethod result = this.adapter.CreateMethod(
() =>
{
delegateCalled = true;
return(new FakeClass());
},
typeof(FakeClass).GetMethod(nameof(FakeClass.MyMethod)));
Assert.That(delegateCalled, Is.False);
Assert.That(FakeClass.ConstructorCount.Value, Is.EqualTo(0));
result(null);
Assert.That(delegateCalled, Is.True);
Assert.That(FakeClass.ConstructorCount.Value, Is.EqualTo(1));
}
public void Get_Performance_Test_Stress()
{
var @object = new FakeClass();
var stopWatch = new Stopwatch();
stopWatch.Start();
var operations = 100000000;
var propertyInfo = typeof(FakeClass).GetProperty("Available2", BindingFlags.Public | BindingFlags.Instance);
var description = new PropertyInfoDescription(propertyInfo);
var myTypeInstrospector = new PropertyAccessor(typeof(FakeClass), description, 0);
for (var i = 0; i < operations; i++)
{
var res = myTypeInstrospector.Get(@object);
}
stopWatch.Stop();
var ts = stopWatch.ElapsedMilliseconds;
_Output.WriteLine($"Perf: {operations* 1000/ts} operations per sec");
}
public void ShouldParseItens()
{
var itens = new List <FakeClass>
{
FakeClass.CreateItem(),
FakeClass.CreateItem(true),
FakeClass.CreateItem(),
FakeClass.CreateItem(true, true),
FakeClass.CreateItem(),
FakeClass.CreateItem(false, true),
};
var worksheet = new MyWorksheet(itens);
var parser = new WorksheetInterpreter <FakeClass>(new ValueSetter(new Converter()), new MyWorksheetMap(), new MessageErrors());
var rowsFake = parser.Parse(worksheet);
itens.ForEach(i => i.Bonus = i.Bonus * 0.1M);
var validationResult = new ValidationResult <FakeClass>();
validationResult.AddItem(itens);
rowsFake.Should().BeEquivalentTo(validationResult);
}
public void ShouldCreateNewColumnsWithErrors()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddWorksheetParser <FakeClass>(x => x.WithParser <ClosedXmlParser <FakeClass> >().WithMap <MyWorksheetMap>());
var serviceProvider = serviceCollection.BuildServiceProvider();
var expectedItens = new List <FakeClass>
{
FakeClass.CreateItem(),
FakeClass.CreateItem(false, false, false),
FakeClass.CreateItem(false, false, true)
};
var parser = serviceProvider.GetService <WorksheetParser <FakeClass> >();
expectedItens.ForEach(x => x.Bonus *= 0.1M);
var validationResult = new ValidationResult <FakeClass>();
var error = new Error("Field TX_NAME can´t not be null", 3, 2);
validationResult.AddError(error);
validationResult.AddItem(expectedItens.First());
validationResult.AddItem(expectedItens.Last());
var headers = new MyWorksheetMap().GetFields().Select(s => s.Name).ToList();
using var worksheet = CreateStream(expectedItens, headers);
var itens = parser.Parse(worksheet, worksheetName);
using var streamWithErros = parser.WriteErrorsWithSummary(worksheet, worksheetName, itens.Errors);
using var workbookWithErrors = new XLWorkbook(streamWithErros);
var reader = new ClosedXmlReader(workbookWithErrors, worksheetName);
reader.CountColumns().Should().Be(headers.Count() + 1);
}
public void DomainEntityComparer_ComparedOnClassNotHandledByEqualsMethod_ThrowsException()
{
var fakeClassForTesting = new FakeClass();
var sut = new DomainEntityComparer();
sut.Equals(fakeClassForTesting, fakeClassForTesting);
}
