public void Exist()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository repository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var agent = Guid.NewGuid();
var entity = Guid.NewGuid();
var data = new List <EntityGuids>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data.Add(s));
repository.AddEntity(agent, entity, EntityType.Driver);
var result = repository.Exist(agent, entity, EntityType.Agent);
Assert.AreEqual(false, result);
result = repository.Exist(agent, entity, EntityType.Driver);
Assert.AreEqual(true, result);
repository.DeleteEntity(agent, entity, EntityType.Driver);
result = repository.Exist(agent, entity, EntityType.Driver);
Assert.AreEqual(false, result);
}
public void AddOrUpdateAgent_Add()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkAgentRepository(logger, entityRepository, rightRepository, mockContext.Object);
var agent = Guid.NewGuid();
var agent1 = Guid.NewGuid();
var mockSet1 = new Mock <DbSet <Right> >();
var data1 = new List <Right>
{
new Right
{
AgentGuid = agent,
EntityType = EntityType.Agent,
OperationTypes = new[] { OperationType.AddOrUpdate }
},
};
var queryable1 = data1.AsQueryable();
mockSet1.As <IQueryable <Right> >().Setup(m => m.Provider).Returns(queryable1.Provider);
mockSet1.As <IQueryable <Right> >().Setup(m => m.Expression).Returns(queryable1.Expression);
mockSet1.As <IQueryable <Right> >().Setup(m => m.ElementType).Returns(queryable1.ElementType);
mockSet1.As <IQueryable <Right> >().Setup(m => m.GetEnumerator()).Returns(queryable1.GetEnumerator());
mockSet1.Setup(d => d.Add(It.IsAny <Right>())).Callback <Right>(s => data1.Add(s));
mockContext.Setup(m => m.Rights).Returns(mockSet1.Object);
var mockSet = new Mock <DbSet <Agent> >();
var data = new List <Agent>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <Agent> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <Agent> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <Agent> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <Agent> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <Agent>())).Callback <Agent>(s => data.Add(s));
mockSet.Setup(m => m.Find(It.IsAny <object[]>())).Returns <object[]>(ids => data.FirstOrDefault(d => d.Id == (int)ids[0]));
mockContext.Setup(m => m.Agents).Returns(mockSet.Object);
var mockSet2 = new Mock <DbSet <EntityGuids> >();
var data2 = new List <EntityGuids>();
var queryable2 = data2.AsQueryable();
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable2.Provider);
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable2.Expression);
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable2.ElementType);
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable2.GetEnumerator());
mockSet2.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data2.Add(s));
mockContext.Setup(m => m.EntityGuids).Returns(mockSet2.Object);
var addOrUpdateAgent = repository.AddOrUpdateAgent(agent, new Agent
{
Id = 0,
Name = "1",
});
var agents = entityRepository.GetEntitys(agent, EntityType.Agent);
Assert.AreEqual(1, agents.Count);
Assert.AreEqual(addOrUpdateAgent.Guid, agents[0]);
}
public void UpdateRights_NotRight()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository entityFrameworkEntityRepository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var agent = Guid.NewGuid();
var agent1 = Guid.NewGuid();
var agent2 = Guid.NewGuid();
var data = new List <EntityGuids>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data.Add(s));
entityFrameworkEntityRepository.AddEntity(agent, agent1, EntityType.Agent);
entityFrameworkEntityRepository.AddEntity(agent1, agent2, EntityType.Agent);
var mockSet1 = new Mock <DbSet <Right> >();
var data1 = new List <Right>();
var queryable1 = data1.AsQueryable();
mockSet1.As <IQueryable <Right> >().Setup(m => m.Provider).Returns(queryable1.Provider);
mockSet1.As <IQueryable <Right> >().Setup(m => m.Expression).Returns(queryable1.Expression);
mockSet1.As <IQueryable <Right> >().Setup(m => m.ElementType).Returns(queryable1.ElementType);
mockSet1.As <IQueryable <Right> >().Setup(m => m.GetEnumerator()).Returns(queryable1.GetEnumerator());
mockSet1.Setup(d => d.Add(It.IsAny <Right>())).Callback <Right>(s => data1.Add(s));
mockContext.Setup(m => m.Rights).Returns(mockSet1.Object);
var repository = new EntityFrameworkRightRepository(new NLogLoggerService(), mockContext.Object, entityFrameworkEntityRepository);
repository.UpdateRights(agent1, agent2, EntityType.Agent, new OperationType[0]);
}
public void AddOrUpdateCart_CannotAccesToAdd()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkCarRepository(logger, entityRepository, rightRepository, mockContext.Object);
var agent = Guid.NewGuid();
var mockSet1 = new Mock <DbSet <Right> >();
var data1 = new List <Right>
{
new Right
{
AgentGuid = agent,
EntityType = EntityType.Car,
OperationTypes = new[] { OperationType.Select }
},
};
var queryable1 = data1.AsQueryable();
mockSet1.As <IQueryable <Right> >().Setup(m => m.Provider).Returns(queryable1.Provider);
mockSet1.As <IQueryable <Right> >().Setup(m => m.Expression).Returns(queryable1.Expression);
mockSet1.As <IQueryable <Right> >().Setup(m => m.ElementType).Returns(queryable1.ElementType);
mockSet1.As <IQueryable <Right> >().Setup(m => m.GetEnumerator()).Returns(queryable1.GetEnumerator());
mockSet1.Setup(d => d.Add(It.IsAny <Right>())).Callback <Right>(s => data1.Add(s));
mockContext.Setup(m => m.Rights).Returns(mockSet1.Object);
repository.AddOrUpdateCar(agent, new Car
{
Id = 1,
Number = "1"
});
}
public void DeleteCar_IdNotValid()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkCarRepository(logger, entityRepository, rightRepository, mockContext.Object);
repository.DeleteCar(Guid.NewGuid(), new Car());
}
public void DeleteAgent_AgentNull()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkAgentRepository(logger, entityRepository, rightRepository, mockContext.Object);
repository.DeleteAgent(Guid.NewGuid(), null);
}
public void DeleteAgent_GuidAgentEmpty()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkAgentRepository(logger, entityRepository, rightRepository, mockContext.Object);
repository.DeleteAgent(Guid.Empty, new Agent());
}
public void GetCarsByGuids_GuidsNull()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkCarRepository(logger, entityRepository, rightRepository, mockContext.Object);
repository.GetCarsByGuids(Guid.NewGuid(), null);
}
public void AddEntity_EntityGuidEmpty()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository repository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
repository.AddEntity(Guid.NewGuid(), Guid.Empty, EntityType.Car);
}
public void GetAgentsByGuids_GuidsEmpty()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkAgentRepository(logger, entityRepository, rightRepository, mockContext.Object);
repository.GetAgentsByGuids(Guid.NewGuid(), new List <Guid>());
}
public void GetRights_AgentEmpty()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository entityFrameworkEntityRepository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var repository = new EntityFrameworkRightRepository(new NLogLoggerService(), mockContext.Object, entityFrameworkEntityRepository);
repository.GetRights(Guid.Empty, EntityType.Agent);
}
public void AddOrUpdateCar_UpdateWithEmptyGuid()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkCarRepository(logger, entityRepository, rightRepository, mockContext.Object);
var agent = Guid.NewGuid();
var mockSet1 = new Mock <DbSet <Right> >();
var data1 = new List <Right>
{
new Right
{
AgentGuid = agent,
EntityType = EntityType.Car,
OperationTypes = new[] { OperationType.AddOrUpdate }
},
};
var queryable1 = data1.AsQueryable();
mockSet1.As <IQueryable <Right> >().Setup(m => m.Provider).Returns(queryable1.Provider);
mockSet1.As <IQueryable <Right> >().Setup(m => m.Expression).Returns(queryable1.Expression);
mockSet1.As <IQueryable <Right> >().Setup(m => m.ElementType).Returns(queryable1.ElementType);
mockSet1.As <IQueryable <Right> >().Setup(m => m.GetEnumerator()).Returns(queryable1.GetEnumerator());
mockSet1.Setup(d => d.Add(It.IsAny <Right>())).Callback <Right>(s => data1.Add(s));
mockContext.Setup(m => m.Rights).Returns(mockSet1.Object);
var mockSet = new Mock <DbSet <Car> >();
var data = new List <Car>
{
new Car
{
Id = 1,
Number = "1"
},
};
var queryable = data.AsQueryable();
mockSet.As <IQueryable <Car> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <Car> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <Car> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <Car> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <Car>())).Callback <Car>(s => data.Add(s));
mockSet.Setup(m => m.Find(It.IsAny <object[]>())).Returns <object[]>(ids => data.FirstOrDefault(d => d.Id == (int)ids[0]));
mockContext.Setup(m => m.Cars).Returns(mockSet.Object);
repository.AddOrUpdateCar(agent, new Car
{
Id = 1,
Number = "1",
});
}
public void AddEntity()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository repository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var data = new List <EntityGuids>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data.Add(s));
repository.AddEntity(Guid.NewGuid(), Guid.NewGuid(), EntityType.Car);
mockSet.Verify(m => m.Add(It.IsAny <EntityGuids>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public void DeleteEntity_EntityNotFound()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository repository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var data = new List <EntityGuids>
{
new EntityGuids {
AgentGuid = Guid.NewGuid(), EntityGuid = Guid.NewGuid(), EntityType = EntityType.Car
},
}.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
repository.DeleteEntity(Guid.NewGuid(), Guid.NewGuid(), EntityType.Car);
}
public void GetRights()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository entityFrameworkEntityRepository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var agent = Guid.NewGuid();
var agent1 = Guid.NewGuid();
var agent2 = Guid.NewGuid();
var data = new List <EntityGuids>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data.Add(s));
entityFrameworkEntityRepository.AddEntity(agent, agent1, EntityType.Agent);
entityFrameworkEntityRepository.AddEntity(agent1, agent2, EntityType.Agent);
var mockSet1 = new Mock <DbSet <Right> >();
var data1 = new List <Right>
{
new Right
{
AgentGuid = agent1,
EntityType = EntityType.Agent,
OperationTypes = new[] { OperationType.Admin }
},
new Right
{
AgentGuid = agent,
EntityType = EntityType.Agent,
OperationTypes = new[] { OperationType.Admin }
}
};
var queryable1 = data1.AsQueryable();
mockSet1.As <IQueryable <Right> >().Setup(m => m.Provider).Returns(queryable1.Provider);
mockSet1.As <IQueryable <Right> >().Setup(m => m.Expression).Returns(queryable1.Expression);
mockSet1.As <IQueryable <Right> >().Setup(m => m.ElementType).Returns(queryable1.ElementType);
mockSet1.As <IQueryable <Right> >().Setup(m => m.GetEnumerator()).Returns(queryable1.GetEnumerator());
mockSet1.Setup(d => d.Add(It.IsAny <Right>())).Callback <Right>(s => data1.Add(s));
mockContext.Setup(m => m.Rights).Returns(mockSet1.Object);
var repository = new EntityFrameworkRightRepository(new NLogLoggerService(), mockContext.Object, entityFrameworkEntityRepository);
repository.UpdateRights(agent1, agent2, EntityType.Agent, new[] { OperationType.Select });
repository.UpdateRights(agent1, agent2, EntityType.Driver, new[] { OperationType.Select });
repository.UpdateRights(agent1, agent2, EntityType.Car, new[] { OperationType.Select });
var rights = repository.GetRights(agent2, EntityType.Agent);
Assert.AreEqual(1, rights.Length);
Assert.AreEqual(OperationType.Select, rights[0]);
rights = repository.GetRights(agent2, EntityType.Driver);
Assert.AreEqual(1, rights.Length);
Assert.AreEqual(OperationType.Select, rights[0]);
rights = repository.GetRights(agent2, EntityType.Car);
Assert.AreEqual(1, rights.Length);
Assert.AreEqual(OperationType.Select, rights[0]);
repository.UpdateRights(agent1, agent2, EntityType.Car, new[] { OperationType.Delete, OperationType.AddOrUpdate });
rights = repository.GetRights(agent2, EntityType.Car);
Assert.AreEqual(2, rights.Length);
Assert.AreEqual(OperationType.Delete, rights[0]);
Assert.AreEqual(OperationType.AddOrUpdate, rights[1]);
repository.UpdateRights(agent, agent1, EntityType.Agent, new[] { OperationType.Select });
try
{
repository.UpdateRights(agent1, agent2, EntityType.Car, new[] { OperationType.Delete, OperationType.AddOrUpdate });
Assert.Fail();
}
catch (InvalidDataException)
{
}
}
public void GetEntitys_Hierarchy()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository repository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var agent = Guid.NewGuid();
var entity = Guid.NewGuid();
var agent1 = Guid.NewGuid();
var entity1 = Guid.NewGuid();
var entity2 = Guid.NewGuid();
var entity3 = Guid.NewGuid();
var data = new List <EntityGuids>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data.Add(s));
repository.AddEntity(agent, entity, EntityType.Driver);
repository.AddEntity(agent, agent1, EntityType.Agent);
repository.AddEntity(agent1, entity1, EntityType.Driver);
repository.AddEntity(agent1, entity2, EntityType.Car);
repository.AddEntity(agent1, entity3, EntityType.Car);
var agents = repository.GetEntitys(agent, EntityType.Agent);
Assert.AreEqual(1, agents.Count);
Assert.AreEqual(agent1, agents[0]);
var drivers = repository.GetEntitys(agent, EntityType.Driver);
Assert.AreEqual(2, drivers.Count);
Assert.AreEqual(entity, drivers[1]);
Assert.AreEqual(entity1, drivers[0]);
drivers = repository.GetEntitys(agent1, EntityType.Driver);
Assert.AreEqual(1, drivers.Count);
Assert.AreEqual(entity1, drivers[0]);
var cars = repository.GetEntitys(agent1, EntityType.Car);
Assert.AreEqual(2, cars.Count);
Assert.AreEqual(entity2, cars[0]);
Assert.AreEqual(entity3, cars[1]);
cars = repository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(2, cars.Count);
Assert.AreEqual(entity2, cars[0]);
Assert.AreEqual(entity3, cars[1]);
repository.DeleteEntity(agent, entity3, EntityType.Car);
cars = repository.GetEntitys(agent1, EntityType.Car);
Assert.AreEqual(1, cars.Count);
Assert.AreEqual(entity2, cars[0]);
cars = repository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(1, cars.Count);
Assert.AreEqual(entity2, cars[0]);
repository.DeleteEntity(agent1, entity1, EntityType.Driver);
drivers = repository.GetEntitys(agent, EntityType.Driver);
Assert.AreEqual(1, drivers.Count);
Assert.AreEqual(entity, drivers[0]);
drivers = repository.GetEntitys(agent1, EntityType.Driver);
Assert.AreEqual(0, drivers.Count);
repository.DeleteEntity(agent1, entity2, EntityType.Car);
cars = repository.GetEntitys(agent1, EntityType.Car);
Assert.AreEqual(0, cars.Count);
cars = repository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(0, cars.Count);
repository.DeleteEntity(agent, entity, EntityType.Driver);
drivers = repository.GetEntitys(agent, EntityType.Driver);
Assert.AreEqual(0, drivers.Count);
drivers = repository.GetEntitys(agent1, EntityType.Driver);
Assert.AreEqual(0, drivers.Count);
repository.DeleteEntity(agent, agent1, EntityType.Agent);
agents = repository.GetEntitys(agent, EntityType.Agent);
Assert.AreEqual(0, agents.Count);
}
public void GetCarsByGuids()
{
var mockContext = new Mock <ApplicationContext>();
var logger = new NLogLoggerService();
var entityRepository = new EntityFrameworkEntityRepository(logger, mockContext.Object);
var rightRepository = new EntityFrameworkRightRepository(logger, mockContext.Object, entityRepository);
var repository = new EntityFrameworkCarRepository(logger, entityRepository, rightRepository, mockContext.Object);
var agent = Guid.NewGuid();
var mockSet1 = new Mock <DbSet <Right> >();
var data1 = new List <Right>
{
new Right
{
AgentGuid = agent,
EntityType = EntityType.Car,
OperationTypes = new[] { OperationType.AddOrUpdate, OperationType.Select, OperationType.Delete }
},
};
var queryable1 = data1.AsQueryable();
mockSet1.As <IQueryable <Right> >().Setup(m => m.Provider).Returns(queryable1.Provider);
mockSet1.As <IQueryable <Right> >().Setup(m => m.Expression).Returns(queryable1.Expression);
mockSet1.As <IQueryable <Right> >().Setup(m => m.ElementType).Returns(queryable1.ElementType);
mockSet1.As <IQueryable <Right> >().Setup(m => m.GetEnumerator()).Returns(queryable1.GetEnumerator());
mockSet1.Setup(d => d.Add(It.IsAny <Right>())).Callback <Right>(s => data1.Add(s));
mockContext.Setup(m => m.Rights).Returns(mockSet1.Object);
var mockSet = new Mock <DbSet <Car> >();
var data = new List <Car>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <Car> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <Car> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <Car> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <Car> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <Car>())).Callback <Car>(s =>
{
s.Id++;
data.Add(s);
});
mockSet.Setup(m => m.Find(It.IsAny <object[]>())).Returns <object[]>(ids => data.FirstOrDefault(d => d.Id == (int)ids[0]));
mockContext.Setup(m => m.Cars).Returns(mockSet.Object);
var mockSet2 = new Mock <DbSet <EntityGuids> >();
var data2 = new List <EntityGuids>();
var queryable2 = data2.AsQueryable();
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable2.Provider);
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable2.Expression);
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable2.ElementType);
mockSet2.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable2.GetEnumerator());
mockSet2.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data2.Add(s));
mockContext.Setup(m => m.EntityGuids).Returns(mockSet2.Object);
var addOrUpdateCar = repository.AddOrUpdateCar(agent, new Car
{
Id = 0,
Number = "1",
});
var cars = entityRepository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(1, cars.Count);
Assert.AreEqual(addOrUpdateCar.Guid, cars[0]);
var carsByGuids = repository.GetCarsByGuids(agent, new List <Guid> {
addOrUpdateCar.Guid
});
Assert.AreEqual(1, carsByGuids.Count);
Assert.AreEqual("1", carsByGuids[0].Number);
Assert.AreEqual(addOrUpdateCar.Id, carsByGuids[0].Id);
Assert.AreEqual(addOrUpdateCar.Guid, carsByGuids[0].Guid);
addOrUpdateCar.Number = "22";
repository.AddOrUpdateCar(agent, addOrUpdateCar);
carsByGuids = repository.GetCarsByGuids(agent, new List <Guid> {
addOrUpdateCar.Guid
});
Assert.AreEqual(1, carsByGuids.Count);
Assert.AreEqual("22", carsByGuids[0].Number);
Assert.AreEqual(addOrUpdateCar.Id, carsByGuids[0].Id);
Assert.AreEqual(addOrUpdateCar.Guid, carsByGuids[0].Guid);
repository.DeleteCar(agent, addOrUpdateCar);
cars = entityRepository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(0, cars.Count);
}
public void GetEntitys_Simple()
{
var mockSet = new Mock <DbSet <EntityGuids> >();
var mockContext = new Mock <ApplicationContext>();
mockContext.Setup(m => m.EntityGuids).Returns(mockSet.Object);
IEntityRepository repository = new EntityFrameworkEntityRepository(new NLogLoggerService(), mockContext.Object);
var agent = Guid.NewGuid();
var entity = Guid.NewGuid();
var agent1 = Guid.NewGuid();
var entity1 = Guid.NewGuid();
var entity2 = Guid.NewGuid();
var entity3 = Guid.NewGuid();
var data = new List <EntityGuids>();
var queryable = data.AsQueryable();
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Provider).Returns(queryable.Provider);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.Expression).Returns(queryable.Expression);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.ElementType).Returns(queryable.ElementType);
mockSet.As <IQueryable <EntityGuids> >().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
mockSet.Setup(d => d.Add(It.IsAny <EntityGuids>())).Callback <EntityGuids>(s => data.Add(s));
repository.AddEntity(agent, entity, EntityType.Car);
repository.AddEntity(agent1, entity1, EntityType.Car);
var guids = repository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(1, guids.Count);
Assert.AreEqual(entity, guids[0]);
guids = repository.GetEntitys(agent1, EntityType.Car);
Assert.AreEqual(1, guids.Count);
Assert.AreEqual(entity1, guids[0]);
repository.DeleteEntity(agent, entity, EntityType.Car);
guids = repository.GetEntitys(agent, EntityType.Car);
Assert.AreEqual(0, guids.Count);
guids = repository.GetEntitys(agent1, EntityType.Car);
Assert.AreEqual(1, guids.Count);
Assert.AreEqual(entity1, guids[0]);
repository.AddEntity(agent1, entity3, EntityType.Driver);
repository.AddEntity(agent1, entity2, EntityType.Driver);
guids = repository.GetEntitys(agent1, EntityType.Car);
Assert.AreEqual(1, guids.Count);
guids = repository.GetEntitys(agent1, EntityType.Driver);
Assert.AreEqual(2, guids.Count);
Assert.AreEqual(entity3, guids[0]);
Assert.AreEqual(entity2, guids[1]);
try
{
repository.DeleteEntity(agent1, entity3, EntityType.Car);
Assert.Fail();
}
catch (InvalidDataException)
{
}
repository.DeleteEntity(agent1, entity3, EntityType.Driver);
guids = repository.GetEntitys(agent1, EntityType.Driver);
Assert.AreEqual(1, guids.Count);
Assert.AreEqual(entity2, guids[0]);
repository.DeleteEntity(agent1, entity2, EntityType.Driver);
guids = repository.GetEntitys(agent1, EntityType.Driver);
Assert.AreEqual(0, guids.Count);
}
