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;
}
