public void WorkersBusy() { var msg1 = new DispatchEvent(new FakeEvent()); var msg2 = new DispatchEvent(new FakeEvent()); var msg3 = new DispatchEvent(new FakeEvent()); var evt = new ManualResetEvent(false); var context = new FakeContext(X => evt.WaitOne()); var dispatcher = new AsyncHandler(2); // make first worker busy and validate dispatcher.HandleDownstream(context, msg1); Assert.True(context.Wait(TimeSpan.FromMilliseconds(100))); context.Reset(); // make second worker busy and validate dispatcher.HandleDownstream(context, msg2); Assert.True(context.Wait(TimeSpan.FromMilliseconds(100))); context.Reset(); // Make sure that the third message is not dispatched. dispatcher.HandleDownstream(context, msg3); Assert.False(context.Wait(TimeSpan.FromMilliseconds(100))); context.Reset(); // release workers. evt.Set(); // and expect the third to get running. Assert.True(context.Wait(TimeSpan.FromMilliseconds(100))); }
public void TestInitialize() { //initialize fakes _fakeContext = new FakeContext(new EntityStructureProvider()); _fakeRepository = new FakeRepository(_fakeContext); //initialize the tested class _customerComponent = new CustomerComponent(_fakeRepository); }
public void Shutdown_ReleaseAfter1Second() { var msg1 = new DispatchEvent(new FakeEvent()); var evt = new ManualResetEvent(false); var context = new FakeContext(X => Thread.Sleep(1000)); var dispatcher = new AsyncHandler(2); dispatcher.HandleDownstream(context, msg1); dispatcher.Close(); }
public void Setup() { fakeContext = new FakeContext(); fakeOrder = new FakeOrder(); fakeProduct = new FakeProduct(); fakeContext.AddObject("Orders", fakeOrder); fakeContext.AddObject("Product", fakeProduct); orders = fakeContext.BaseUri + "/Orders()?"; }
public void RegularDispatch() { var dispatcher = new AsyncHandler(5); var msg = new DispatchEvent(new FakeEvent()); var context = new FakeContext(); dispatcher.HandleDownstream(context, msg); Assert.True(context.Wait(TimeSpan.FromMilliseconds(50000))); Assert.Same(msg, context.Message); }
public void try_a_simple_constructor_with_all_constants() { var step = ConcreteBuild<CtorTarget>.For(() => new CtorTarget("", 0)); step.Constructor.Add(Constant.For("Jeremy")); step.Constructor.Add(Constant.For<int>(39)); var context = new FakeContext(); var builder = (Func<IContext, CtorTarget>)step.ToDelegate(); var target = builder(context); target.Name.ShouldEqual("Jeremy"); target.Age.ShouldEqual(39); }
public void Shutdown_NotReleased() { var msg1 = new DispatchEvent(new FakeEvent()); var evt = new ManualResetEvent(false); var context = new FakeContext(X => evt.WaitOne()); var dispatcher = new AsyncHandler(2); dispatcher.HandleDownstream(context, msg1); Assert.Throws<InvalidOperationException>(() => dispatcher.Close()); evt.Set(); // and expect the third to get running. Assert.True(context.Wait(TimeSpan.FromMilliseconds(100))); }
private static Task <IActionResult> CriaControllerEUtilizaAService( string fullName = null, string email = null, string password = null, string confirmPassword = null, string token = null) { var fakeContext = new FakeContext("AccountManagerControllerTests"); var fakeService = fakeContext.FakeAuthenticationRepository().Object; var controller = new AuthenticationController(); if (confirmPassword != null) { var registerCreateDTO = new RegisterCreateDTO { FullName = fullName, Email = email, Password = password, ConfirmPassword = confirmPassword }; return(controller.Register(fakeService, registerCreateDTO)); } else if (token != null) { return(controller.ConfirmEmail(fakeService, fakeContext._configuration, email, token)); } else if (password != null && confirmPassword == null) { var loginCreateDTO = new LoginCreateDTO { Email = email, Password = password }; return(controller.SignIn(fakeService, loginCreateDTO)); } else { var forgotPasswordDTO = new ForgotPasswordDTO { Email = email }; return(controller.ForgotPassword(fakeService, forgotPasswordDTO)); } }
void TestSelectingBookThatDoentExists() { var dbContext = new FakeContext(); dbContext.Books = new[] { new Book() { ID = 1 }, new Book() { ID = 2 }, }.AsQueryable(); booksController = new BooksController(dbContext); var result = booksController.Details(3); Assert.IsType <NotFoundResult>(result); }
public void Deve_Falhar_Ao_Postar_Error_Com_Source_Invalido(string title, string details, int sourceId, Level level) { FakeContext fakeContext = CreateAndFillContextWithError(); using (var context = new CentralDeErrorContext(fakeContext.FakeOptions)) { var newSource = new ErrorCreateDTO { Title = title, Details = details, SourceId = sourceId, Level = level }; var service = CreateService(fakeContext, context); Assert.IsNotNull(newSource); var user = context.Users.FirstOrDefault(); var identity = new[] { new Claim("Name", user.Id) }; var result = service.Create(newSource, new ClaimsPrincipal(new ClaimsIdentity(identity))); Assert.AreEqual(false, result.Success); Assert.AreEqual("Invalid Source Id.", result.Message); Assert.AreEqual(null, result.Data); } }
public void Test_GetById_Sale(int id) { var fakeContext = new FakeContext("GetById_Sale"); fakeContext.FillWith <Sale>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var expected = fakeContext.GetFakeData <Sale>().Find(x => x.Id == id); var repository = new SaleRepository(context); var actual = repository.GetById(id); Assert.IsType <SaleRepository>(repository); Assert.IsType <Sale>(actual); Assert.Equal(expected.CreatedAt, actual.CreatedAt); Assert.Equal(expected.UpdatedAt, actual.UpdatedAt); Assert.Equal(expected.Id, actual.Id); Assert.Equal(expected.ProductId, actual.ProductId); Assert.Equal(expected.Quantity, actual.Quantity); Assert.Equal(expected.Total, actual.Total); } }
public void Test_Return_Message_When_Id_NotFound_Warehouse() { var fakeContext = new FakeContext("Return_Message_When_Id_NotFound_Warehouse"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var repository = new ProductRepository(context); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Product>())) .Returns(Task.CompletedTask); var service = new ProductService(repository, messageMock.Object); var currentProduct = service.GetById(1); var response = service.Update(6, currentProduct); Assert.Equal("{ Message = Produto não encontrado. }", response.ToString()); } }
public void Test_Return_Null_When_Id_NotFound_Warehouse() { var fakeContext = new FakeContext("Return_Null_When_Id_NotFound_Warehouse"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var repository = new ProductRepository(context); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Product>())) .Returns(Task.CompletedTask); var service = new ProductService(repository, messageMock.Object); var currentProduct = service.GetById(1); Assert.Null(service.GetById(6)); Assert.Null(service.GetById(-10)); Assert.Null(service.GetById(0)); } }
void TestSelectingBook() { var dbContext = new FakeContext(); var expectedBook = new Book() { ID = 1 }; dbContext.Books = new[] { expectedBook, new Book() { ID = 2 }, }.AsQueryable(); booksController = new BooksController(dbContext); var result = booksController.Details(1) as ViewResult; Assert.Equal(expectedBook, result.Model as Book); }
public void Test_GetAll_Products_Warehouse_Service() { var fakeContext = new FakeContext("GetAllProducts_Warehouse_Service"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var countProducts = context.Products.Count(); var repository = new ProductRepository(context); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Product>())) .Returns(Task.CompletedTask); var service = new ProductService(repository, messageMock.Object); Assert.Equal(countProducts, service.GetAll().Count()); Assert.IsType <ProductRepository>(repository); Assert.IsType <ProductService>(service); } }
public void Should_Get_By_Environment_And_Description(int environmentId, string description) { var fakeContext = new FakeContext("DeleteLogLog"); fakeContext.FillWith <Log>(); using (var context = new MainContext(fakeContext.FakeOptions)) { var repository = new LogRepository(context); var validator = new LogValidator(); var service = new LogService(repository, validator, context); var logByEnvAndDescriptionId = service .GetByEnvironmentAndDescription(environmentId, description); foreach (var log in logByEnvAndDescriptionId) { Assert.Contains("tentar", log.Description); } Assert.NotEmpty(logByEnvAndDescriptionId); Assert.NotNull(logByEnvAndDescriptionId); } }
public void Should_Create_New_User_Properly(int id) { var fakeContext = new FakeContext("UserModelTest"); fakeContext.FillWith <User>(); using (var context = new MainContext(fakeContext.FakeOptions)) { var repository = new UserRepository(context); var validator = new UserValidator(context); var service = new UserService(repository, validator); var testUser = service.GetById(id); Assert.NotNull(testUser.FullName); Assert.NotNull(testUser.Email); Assert.NotNull(testUser.Password); Assert.NotNull(testUser.Id); Assert.NotNull(testUser.CreatedAt); Assert.IsType <DateTime>(testUser.CreatedAt); repository.Dispose(); } }
public async Task Deposit_Transaction_Created() { // Arrange IDateTime time = new MockDateTime(); var context = FakeContext.Get(); // Act var sut = new CreateAccountDepositCommandHandler(context, time); await sut.Handle(new CreateAccountDepositCommand() { AccountId = 1, Amount = 500m }, CancellationToken.None); // Assert var transaction = context.Transactions.Single(t => t.AccountId == 1); transaction.AccountId.ShouldBe(1); transaction.Amount.ShouldBe(500m); transaction.Balance.ShouldBe(1000m); transaction.Type.ShouldBe(TransactionType.Credit); transaction.Operation.ShouldBe(Operation.Credit); }
public void Should_Save_New_Layer_To_Db() { var fakeContext = new FakeContext("AddNewLayer"); var fakeLayer = new Layer(); fakeLayer.Name = "Desenvolvimento"; fakeLayer.Id = 4; using (var context = new MainContext(fakeContext.FakeOptions)) { var repository = new LayerRepository(context); repository.Create(fakeLayer); var createdLayer = repository.GetById(4); Assert.NotEqual(0, fakeLayer.Id); Assert.Equal("Desenvolvimento", createdLayer.Name); Assert.Equal(4, createdLayer.Id); repository.Dispose(); } }
public void Testing_connection() // Succeeds { var context = new FakeContext(Effort.DbConnectionFactory.CreateTransient()); var connection = (EffortConnection)context.Database.Connection; var trans = connection.BeginTransaction(); using (var unit = context.Database.Connection.BeginTransaction()) { Console.WriteLine(unit.IsolationLevel); var fake = new DummyObject { Id = Guid.NewGuid(), DummyProp = "Hello" }; context.DummyObjects.Add(fake); context.SaveChanges(); var results = context.DummyObjects.ToList(); unit.Commit(); } }
private static void FirstUserAsNull() { try { Console.WriteLine("OneUserAsNull"); FakeContext ctx = new FakeContext(); ctx.user_mstr = new List <user_mstr>() { null, new user_mstr(), new user_mstr() }; user_mstr vwUser = ctx.user_mstr.FirstOrDefault(x => x.user_cd == strUserCD); } catch (NullReferenceException e) { Console.WriteLine(e.Message); } catch (ArgumentNullException e) { Console.WriteLine(e.Message); Console.WriteLine(); } }
public async Task Update() { // Arrange const string newName = "New Name"; var entity = new FakeEntity("Name"); var databaseName = $"{DatabaseNamePrefix}.{nameof(Update)}"; var options = new DbContextOptionsBuilder <FakeContext>() .UseInMemoryDatabase(databaseName) .Options; using (var context = new FakeContext(options)) { context.Add(entity); await context.SaveChangesAsync(); } entity.Name = newName; var keyValues = new object[] { entity.Id }; var mapper = new Mock <IMapper>(); mapper.Setup(x => x.Map <FakeEntity>(It.IsAny <object>())).Returns(entity); var request = new Mock <UpdateRequest <FakeEntity, object> >(new object()); // Act using (var context = new FakeContext(options)) { var requestHandler = new FakeUpdateRequestHandler(context, mapper.Object); await requestHandler.Handle(request.Object, CancellationToken.None); } // Assert using (var context = new FakeContext(options)) { entity = await context.FindAsync <FakeEntity>(keyValues); Assert.Equal(newName, entity.Name); } }
static async Task Main(string[] args) { var context = new FakeContext(); /*context.Agent.RegisterAgent("TestAgent", () => { * var agent = new TestAgent(); * agent.RegisterFunction("TestAgent", (int input) => { * Debug.Assert(input == 42); * return 78; * }); * return agent; * });*/ context.Agent.RegisterAgent("TestAgent", () => context.Agent); context.Agent.RegisterFunction("TestAgent", (int input) => { Debug.Assert(input == 42); return(78); }); context.Agent.RegisterFunction("Dynamic", (dynamic item) => { Debug.Assert((string)item.Message == "This was read from a dynamic object!"); return(new { Sum = item.A + item.B }); }); context.Agent.RegisterFunction("Log", (string input) => { Debug.Assert(input == $"TestAgent returned 78"); }); var state = new FakeState(); var result = await Launcher.StatefulSum(10, state, default); Debug.Assert(result == 10); Debug.Assert(state.GetValue <int>("StatefulSum") == 10); await Launcher.RunAsync(true, context, state, default); }
public void Should_Be_OK_Post() { var fakes = new FakeContext("ErrorControllerPost"); var fakeErrorOccurrenceService = fakes.FakeErrorOccurrenceService().Object; var fakeLevelService = fakes.FakeLevelService().Object; var fakeEnvironmentService = fakes.FakeEnvironmentService().Object; var contexto = new CentralErroContexto(fakes.FakeOptions); List <ErrorOccurrenceDTO> expected = fakes.GetFakeData <ErrorOccurrenceDTO>(); var controller = new ErrorOccurrenceController(fakes.Mapper, contexto, fakeErrorOccurrenceService, fakeLevelService, fakeEnvironmentService); foreach (var item in expected) { var result = controller.Post(item); Assert.IsType <OkObjectResult>(result.Result); var actual = (result.Result as OkObjectResult).Value as List <ErrorOccurrenceDTO>; Assert.NotNull(actual); Assert.Equal(expected.Count, actual.Count); foreach (var atual in actual) { foreach (var exp in expected) { Assert.Equal(exp.Title, atual.Title); Assert.Equal(exp.Details, atual.Details); Assert.Equal(exp.Username, atual.Username); Assert.Equal(exp.Origin, atual.Origin); Assert.Equal(exp.EnvironmentId, atual.EnvironmentId); Assert.Equal(exp.LevelId, atual.LevelId); Assert.Equal(exp.EventId, atual.EventId); } } } }
public void Test_ProductController_GetAll_Warehouse() { var fakeContext = new FakeContext("Test_ProductController_GetAll_Warehouse"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var repository = new ProductRepository(context); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Product>())) .Returns(Task.CompletedTask); var config = new MapperConfiguration(cfg => { cfg.CreateMap <ProductDto, Product>(); cfg.CreateMap <Product, ProductDto>(); }); var mapper = config.CreateMapper(); var validator = new Mock <IValidator <Product> >(); validator.Setup(x => x.Validate(It.IsAny <Product>())).Returns(new ValidationResult()); var service = new ProductService(repository, messageMock.Object); var controller = new ProductController(service, mapper, validator.Object); var response = controller.GetAll(); var okResult = response as OkObjectResult; var resultValue = okResult.Value; Assert.NotNull(okResult); Assert.Equal(200, okResult.StatusCode); Assert.Equal(repository.GetAll(), okResult.Value); Assert.IsType <List <Product> >(resultValue); } }
public async void Test_Create_Sale_Service() { var fakeContext = new FakeContext("Create_Sale_Service"); fakeContext.FillWithAll(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var repository = new SaleRepository(context); var productRepository = new ProductRepository(context); var updateMock = new Mock <IUpdateProduct>(); updateMock .Setup(x => x.UpdateStock(It.IsAny <Sale>(), It.IsAny <Sale>())); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Sale>(), It.IsAny <UpdatedSale>())) .Returns(Task.CompletedTask); var service = new SaleService(repository, messageMock.Object, updateMock.Object, productRepository); var sale = new Sale(); sale.ProductId = 1; sale.Quantity = 10; var response = await service.Create(sale); var newSale = (from s in repository.GetAll() where s.Quantity == 10 where s.ProductId == 1 select s).FirstOrDefault(); Assert.IsType <Sale>(newSale); Assert.Equal("{ Message = Venda efetuada com sucesso. }", response.ToString()); Assert.Equal(6, newSale.Id); Assert.Equal(688.80M, newSale.Total); Assert.Equal(2020, newSale.CreatedAt.Year); } }
public void InstantiateWorkflow() { // Arrange var workplan = WorkplanDummy.CreateFull(); // Act var context = new FakeContext(); var workflow = WorkflowFactory.Instantiate(workplan, context); // Simple assert Assert.AreEqual(workplan.Connectors.Count(), workflow.Places.Count(), "Not all connectors transformed to places!"); Assert.AreEqual(workplan.Steps.Count(), workflow.Transitions.Count(), "Not all steps transformed to transitions!"); Assert.IsTrue(workflow.Transitions.Cast <DummyTransition>().All(t => t.Context == context), "Context not passed to all transitions!"); // Structure assert var transitions = workflow.Transitions; Assert.AreEqual(2, transitions[0].Outputs.Length); Assert.AreEqual(transitions[0].Outputs[1], transitions[1].Inputs[0]); Assert.AreEqual(transitions[0].Outputs[0], transitions[2].Inputs[0]); Assert.AreEqual(transitions[1].Outputs[0], transitions[2].Inputs[0]); Assert.AreEqual(transitions[2].Outputs[0], transitions[2].Outputs[1]); Assert.AreEqual(transitions[2].Outputs[0], workflow.EndPlaces().First()); }
public void Test_Update_Product_Warehouse_Service(int id) { var fakeContext = new FakeContext("Update_Products_Warehouse_Service"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var repository = new ProductRepository(context); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Product>())) .Returns(Task.CompletedTask); var service = new ProductService(repository, messageMock.Object); var currentProduct = service.GetById(id); currentProduct.Name = "123abc"; service.Update(id, currentProduct); Assert.Equal("123abc", service.GetById(id).Name); } }
public void Should_Be_Ok_When_Delete_By_Id(int id) { var fakes = new FakeContext("ErrorControllerDelete"); var fakeErrorOccurrenceService = fakes.FakeErrorOccurrenceService().Object; var fakeLevelService = fakes.FakeLevelService().Object; var fakeEnvironmentService = fakes.FakeEnvironmentService().Object; var expected = fakes.Mapper.Map <ErrorOccurrenceDTO>(fakeErrorOccurrenceService.FindById(id)); var contexto = new CentralErroContexto(fakes.FakeOptions); var controller = new ErrorOccurrenceController(fakes.Mapper, contexto, fakeErrorOccurrenceService, fakeLevelService, fakeEnvironmentService); var result = controller.Delete(id); Assert.IsType <OkObjectResult>(result.Result); var actual = (result.Result as OkObjectResult).Value as ErrorOccurrenceDTO; Assert.NotNull(actual); Assert.Equal(expected, actual, new ErrorDTOIdComparer()); }
public void Should_Be_Ok_When_Get_Filed() { var fakes = new FakeContext("ErrorControllerGetFiled"); var fakeErrorOccurrenceService = fakes.FakeErrorOccurrenceService().Object; var fakeLevelService = fakes.FakeLevelService().Object; var fakeEnvironmentService = fakes.FakeEnvironmentService().Object; var expected = fakes.Mapper.Map <List <ErrorOccurrenceDTO> >(fakeErrorOccurrenceService.FindFiledErrors()); var contexto = new CentralErroContexto(fakes.FakeOptions); var controller = new ErrorOccurrenceController(fakes.Mapper, contexto, fakeErrorOccurrenceService, fakeLevelService, fakeEnvironmentService); var result = controller.GetFiled(); Assert.IsType <OkObjectResult>(result.Result); var actual = (result.Result as OkObjectResult).Value as List <ErrorOccurrenceDTO>; Assert.NotNull(actual); Assert.Equal(expected, actual, new ErrorDTOIdComparer()); }
public async Task Transfer_ValidAmounts_CreateTransactions() { // Arrange IDateTime time = new MockDateTime(); var context = FakeContext.Get(); // Act var sut = new CreateAccountTransferCommandHandler(context, time); await sut.Handle(new CreateAccountTransferCommand { AccountIdFrom = 1, AccountIdTo = 2, Amount = 250m }, CancellationToken.None); // Assert var transactionFrom = context.Transactions.Single(t => t.AccountId == 1); var transactionTo = context.Transactions.Single(t => t.AccountId == 2); transactionFrom.Operation.ShouldBe(Operation.TransferDebit); transactionFrom.Type.ShouldBe(TransactionType.Debit); transactionFrom.Amount.ShouldBe(-250m); transactionFrom.Balance.ShouldBe(250m); transactionTo.Operation.ShouldBe(Operation.Transfer); transactionTo.Type.ShouldBe(TransactionType.Credit); transactionTo.Amount.ShouldBe(250m); transactionTo.Balance.ShouldBe(750m); }
public void Should_Get_Log_Info_Right(int id) { var fakeContext = new FakeContext("LogInfo"); fakeContext.FillWith <Log>(); using (var context = new MainContext(fakeContext.FakeOptions)) { var logbuilder = new LogBuilder(context); var repository = new LogRepository(context); var validator = new LogValidator(); var service = new LogService(repository, validator, context); var logTest = service.GetById(id); Assert.NotEqual(0, logTest.UserId); Assert.NotNull(logbuilder.GetPayload(logTest)); Assert.NotEqual(0, logTest.EnvironmentId); Assert.NotEqual(0, logTest.LayerId); Assert.NotEqual(0, logTest.LevelId); Assert.NotEqual(0, logTest.StatusId); context.Dispose(); } }
public void Should_Delete_Status_In_Db() { var fakeContext = new FakeContext("DeleteStatus"); fakeContext.FillWith <Status>(); using (var context = new MainContext(fakeContext.FakeOptions)) { var repository = new StatusRepository(context); var currentCount = context.Status.Count(); var newStatus = new Status(); newStatus.Name = "Testing"; context.Status.Add(newStatus); context.SaveChanges(); var idToDelete = (from s in context.Status.ToList() where s.Id == newStatus.Id select s.Id).FirstOrDefault(); Assert.Equal(currentCount + 1, context.Status.Count()); repository.Delete(idToDelete); Assert.Equal(currentCount, context.Status.Count()); } }
public static void Test_Convert_To_Bytes_And_From_Bytes(int id) { var fakeContext = new FakeContext("Convert_To_Bytes_product"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var repository = new GenericRepository <Product>(context); var service = new GenericService <Product>(repository); var product = service.GetById(id); var byteProduct = product.ToJsonBytes(); var productFromByte = byteProduct.ParseJson <Product>(); Assert.IsType <byte[]>(byteProduct); Assert.IsType <Product>(productFromByte); Assert.Equal(product.CreatedAt, productFromByte.CreatedAt); Assert.Equal(product.UpdatedAt, productFromByte.UpdatedAt); Assert.Equal(product.Name, productFromByte.Name); Assert.Equal(product.Sku, productFromByte.Sku); } }
public void Should_Delete_Layer_In_Db() { var fakeContext = new FakeContext("DeleteLayer"); fakeContext.FillWith <Layer>(); using (var context = new MainContext(fakeContext.FakeOptions)) { var repository = new LayerRepository(context); var currentCount = context.Layer.Count(); var newLayer = new Layer(); newLayer.Name = "Layer"; repository.Create(newLayer); var idToDelete = (from l in repository.GetAll() where l.Id == newLayer.Id select l.Id).FirstOrDefault(); Assert.Equal(currentCount + 1, repository.GetAll().Count()); repository.Delete(idToDelete); Assert.Equal(currentCount, context.Layer.Count()); repository.Dispose(); } }
public void Test_GetById_Products_Warehouse(int id) { var fakeContext = new FakeContext("GetByIdProducts_Warehouse"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { var expected = fakeContext.GetFakeData <Product>().Find(x => x.Id == id); var repository = new GenericRepository <Product>(context); var actual = repository.GetById(id); Assert.IsType <GenericRepository <Product> >(repository); Assert.IsType <Product>(actual); Assert.Equal(expected.CreatedAt, actual.CreatedAt); Assert.Equal(expected.UpdatedAt, actual.UpdatedAt); Assert.Equal(expected.Id, actual.Id); Assert.Equal(expected.Sku, actual.Sku); Assert.Equal(expected.Name, actual.Name); Assert.Equal(expected.Price, actual.Price); Assert.Equal(expected.Quantity, actual.Quantity); } }
public void Testing_no_connection() // Fails with Transaction Aborted { var context = new FakeContext(Effort.DbConnectionFactory.CreateTransient()); var test = context.DummyObjects.ToList(); using (var unit = context.Database.BeginTransaction()) { // Console.WriteLine(unit.UnderlyingTransaction.IsolationLevel); var fake = new DummyObject { Id = Guid.NewGuid(), DummyProp = "Hello" }; context.DummyObjects.Add(fake); context.SaveChanges(); // This is the line that takes 20+ seconds to run causing the transaction to timeout var results = context.DummyObjects.ToList(); unit.Commit(); // unit.Commit(); } }
public void TestSetup() { _fakeContext = new FakeContext(new TestEntityStructureProvider()); }
public FakeRepository(FakeContext fakeContext) { _fakeContext = fakeContext; }