private void ReInit()
{
eFUnitOfWork.Dispose();
eFUnitOfWork = new EFUnitOfWork(new DataContainer(DbConnectionHelper.GetConnectionString()));
charterInRepository = new CharterInRepository(eFUnitOfWork);
// Repository = new CharterRepository(eFUnitOfWork);
}
public AmbientContextSuppressor()
{
_savedScope = EFUnitOfWork.GetAmbientScope();
// We're hiding the ambient scope but not removing its instance
// altogether. This is to be tolerant to some programming errors.
//
// Suppose we removed the ambient scope instance here. If someone
// was to start a parallel task without suppressing
// the ambient context and then tried to suppress the ambient
// context within the parallel task while the original flow
// of execution was still ongoing (a strange thing to do, I know,
// but I'm sure this is going to happen), we would end up
// removing the ambient context instance of the original flow
// of execution from within the parallel flow of execution!
//
// As a result, any code in the original flow of execution
// that would attempt to access the ambient scope would end up
// with a null value since we removed the instance.
//
// It would be a fairly nasty bug to track down. So don't let
// that happen. Hiding the ambient scope (i.e. clearing the CallContext
// in our execution flow but leaving the ambient scope instance untouched)
// is safe.
EFUnitOfWork.HideAmbientScope();
}
public void SetUp()
{
_mockDbContext = new Mock<IDbContext>();
_mockUnitOfWorkRepository = new Mock<IUnitOfWorkRepository<object>>();
_testUnitOfWork = new EFUnitOfWork(_mockDbContext.Object);
_testEntity = new object();
}
public MemberManager()
{
// TODO: IoC refactor
UnitOfWork = new EFUnitOfWork();
MemberSearchEngine = new SearchEngine<McMember>(UnitOfWork.MemberRepo);
ProcessSearchEngine = new SearchEngine<Process>(UnitOfWork.ProcessRepo);
CaseDocSearchEngine = new SearchEngine<CaseDocument>(UnitOfWork.CaseDocumentRepo);
MemberTypeSearchEngine = new SearchEngine<McMemberType>(UnitOfWork.MemberTypeRepo);
}
public void Get()
{
using (var c = new DataContainer(DbConnectionHelper.GetConnectionString()))
{
var g = new EFUnitOfWork(c);
//var rep = new ScrapRepository(g, new ScrapConfigurator(new ScrapStateFactory(new ApprovableScrapDomainService(new VesselDomainService))));
//var res = rep.Find(r => true);
}
}
public void Dispose()
{
if (_disposed)
return;
if (_savedScope != null)
{
EFUnitOfWork.SetAmbientScope(_savedScope);
_savedScope = null;
}
_disposed = true;
}
public void Create(PizzaTypeViewModel pizzaTypeVM)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <PizzaTypeViewModel, PizzaType>();
cfg.CreateMap <SpotViewModel, Spot>().PreserveReferences(); //.PreserveReferences for avoid circuit references => stackoverflowException
cfg.CreateMap <PizzaViewModel, Pizza>();
});
using (database = new EFUnitOfWork(connectionName))
{
database.PizzaTypes.Create(Mapper.Map <PizzaType>(pizzaTypeVM));
database.Save();
}
}
public AddOrUpdateBlogEntryFileCommandHandlerTest()
{
this.unitOfWork = new InMemoryDatabaseFactory().CreateContext();
this.blogEntryFileFileProvider = new Mock <IBlogEntryFileFileProvider>();
this.blogEntry = new BlogEntry()
{
ShortContent = "Test",
Header = "Test"
};
this.unitOfWork.BlogEntries.Add(this.blogEntry);
this.unitOfWork.SaveChanges();
}
public void CanAddFarmer()
{
var farmer = new Farmer()
{
Name = "Новый хитрый фермер"
};
using (var db = new EFUnitOfWork())
{
db.Farmers.Create(farmer);
db.Save();
}
Assert.IsTrue(farmer.Id > 0);
}
public void TraceAuditLogoutUser(SessionInfo sessioninfo)
{
using (EFUnitOfWork unitOfWork = new EFUnitOfWork())
{
//DA_LOGIN_AUDIT foundaudit = unitOfWork.DA_LOGIN_AUDITRepository.GetBySessionInfo(sessioninfo);
DA_LOGIN_AUDIT foundaudit = unitOfWork.DA_LOGIN_AUDITRepository.GetByID(sessioninfo.ID);
if (foundaudit != null)
{
foundaudit.LOGOUT_DATE = DateTime.Now;
foundaudit.RESULT = String.Format("Logout the system on {0}", DateTime.Now.ToString());
}
unitOfWork.Commit();
}
}
public void CreateQuestion_ShouldReturnTrue()
{
var questionDTO = new QuestionDTO {
Id = 6, Text = "someText", Title = "someTitle"
};
using var context = new ApplicationDbContext(options);
var unitOfWork = new EFUnitOfWork(context);
var fakeQuestionService = new QuestionService(unitOfWork, _logger.Object, _mapperToQuestion);
fakeQuestionService.CreateQuestion(questionDTO);
Assert.NotNull(unitOfWork.Questions.Find(e => e.Id == 6).First());
}
public void CreateMessage()
{
//DataBaseInitializer<MessageContext>.InitializedDatabase();
using (BaseContext context = ContextFactory.Create())
{
IUnitOfWork uow = new EFUnitOfWork(context);
IRepositoryGeneric <User> userRepository = uow.GetRepository <User>();//Veri tabanımızı oluşturuyoruz. Varsa default değerleri de insertliyoruz.
User user1 = new User()
{
Name = "Berkay"
};
User user2 = new User()
{
Name = "Arda"
};
userRepository.Add(user1);
userRepository.Add(user2);
uow.SaveChanges();
IRepositoryGeneric <Message> msgRepository = uow.GetRepository <Message>();
msgRepository.Add(new Message()
{
FromUser = user1, ToUser = user2, Text = $"Selam. Nasılsın?", CreateDate = DateTime.Now
});
msgRepository.Add(new Message()
{
FromUser = user2, ToUser = user1, Text = $"İyiyim", CreateDate = DateTime.Now
});
uow.SaveChanges();
Console.WriteLine("Tüm mesajlar cekiliyor...");
foreach (var msg in msgRepository.GetAll())
{
Console.WriteLine(msg.ToString());
System.Diagnostics.Debug.WriteLine(msg.Text.ToString());
HttpContext.Current.Response.Write(msg.Text.ToString());
}
Console.WriteLine("Berkay'ın mesajları çekiliyor");
foreach (var msg in msgRepository.GetAll((m) => m.FromUser.Name == "Berkay"))
{
Console.WriteLine(msg.ToString());
System.Diagnostics.Debug.WriteLine(msg.Text.ToString());
HttpContext.Current.Response.Write(msg.Text.ToString());
}
}
}
public AddBlogEntryCommentCommandHandlerTest()
{
this.unitOfWork = new InMemoryDatabaseFactory().CreateContext();
this.notificationsServiceMock = new Mock <INotificationService>();
this.blogEntry = new BlogEntry()
{
ShortContent = "Test",
Header = "Test"
};
this.unitOfWork.BlogEntries.Add(this.blogEntry);
this.unitOfWork.SaveChanges();
}
public DeleteImageCommandHandlerTest()
{
this.unitOfWork = new InMemoryDatabaseFactory().CreateContext();
this.imageFileProviderMock = new Mock <IImageFileProvider>();
this.image = new Image()
{
Name = "test.png"
};
this.unitOfWork.Images.Add(this.image);
this.unitOfWork.SaveChanges();
Assert.Single(this.unitOfWork.Images);
}
public IncrementBlogEntryVisitsCommandHandlerTest()
{
this.unitOfWork = new InMemoryDatabaseFactory().CreateContext();
this.blogEntry = new BlogEntry()
{
ShortContent = "Test",
Header = "Test"
};
this.unitOfWork.BlogEntries.Add(this.blogEntry);
this.unitOfWork.SaveChanges();
Assert.Single(this.unitOfWork.BlogEntries);
}
public void PsalmsMigrationManager_CsTest()
{
var uof = new EFUnitOfWork();
var service = new FakePsalterService(uof);
var manager = new PsalmsMigrationManager(service);
string folderPath = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\PsalterMigration\1");
manager.MigratePsalms(new PsalterRuReader(folderPath, "cs-ru"));
manager.MigratePsalms(new PsalterCsReader(folderPath, "cs-cs"));
//uof.Commit();
}
public void PsalmsMigrationManager_Test()
{
var uof = new EFUnitOfWork();
var service = new FakePsalterService(uof);
var manager = new PsalmsMigrationManager(service);
string folderPath = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\PsalterMigration");
manager.MigratePsalms(new PsalterRuReader(folderPath, "cs-ru"));
Assert.That(service.Psalms.Count(), Is.EqualTo(150));
//uof.Commit();
}
public static BookStorage Create()
{
EFUnitOfWork _unitOfWork = new EFUnitOfWork();
var easters = new EasterContext(_unitOfWork);
return(new BookStorage(new EvangelionContext(_unitOfWork),
new ApostolContext(_unitOfWork),
new OldTestamentContext(_unitOfWork),
new PsalterContext(_unitOfWork),
new OktoikhContext(_unitOfWork, easters),
new TheotokionAppContext(_unitOfWork),
new EasterContext(_unitOfWork),
new KatavasiaContext(_unitOfWork)));
}
static void test()
{
IUnitOfWork unitOfWork = new EFUnitOfWork();
IRepository <Customer> customerRepo = new Repository <Customer>(unitOfWork);
var entity = customerRepo.Create(new Customer()
{
Name = "SS"
});
customerRepo.Save();
entity.Name = "TT" + entity.ID;
customerRepo.Update(entity);
customerRepo.Save();
}
public async void RejectChangesTest()
{
using var factory = new TestContextFactory();
using var context = factory.CreateContext();
using var unitOfWork = new EFUnitOfWork(context);
context.Database.EnsureCreated();
await unitOfWork.Repository <RandomizerList>().Remove(1);
await unitOfWork.CancelChangesAsync();
await unitOfWork.SaveChangesAsync();
(await unitOfWork.Repository <RandomizerList>().GetItems(0, 10)).Count().Should().Be(3);
}
public async void Delete()
{
using var factory = new TestContextFactory();
using var context = factory.CreateContext();
using var unitOfWork = new EFUnitOfWork(context);
context.Database.EnsureCreated();
var chewie = await unitOfWork.Repository <RandomizerList>().Get(1);
await unitOfWork.Repository <RandomizerList>().Remove(chewie);
await unitOfWork.SaveChangesAsync();
Assert.Empty((await unitOfWork.Repository <RandomizerList>().GetItems(0, 10)).Where(n => n.Name.Equals("Beers")));
}
public async Task EFUnitOfWorkTests_GetAircraft_Asynchronously_ShouldReturnAnAircraftWhenAircraftIdExistsInDatabase()
{
// Arrange
var context = new EFUnitOfWork(_contextBuilder.Options);
// Expected
var expectedAircraft = _aircraftsRecords.First();
// Act
var currentAircraft = await context.CreateSet <Aircraft>().FindAsync(expectedAircraft.Id);
// Assert
Check.That(currentAircraft).IsNotNull();
Check.That(currentAircraft).HasFieldsWithSameValues(expectedAircraft);
}
public static ContentService CreateContentService()
{
IUnitOfWork uow = new EFUnitOfWork();
IArticleRepository articleRepository = new ArticleRepository(uow);
ISiteNodeRepository siteNodeRepository = new SiteNodeRepository(uow);
INewsRepository newsRepository = new NewsRepository(uow);
ICompanyRepository companyRepository = new CompanyRepository(uow);
IIdeaRepository ideaRepository = new IdeaRepository(uow);
ICommentRepository commentRepository = new CommentRepository(uow);
IVacancyRepository vacancyRepository = new VacancyRepository(uow);
IAnnouncementRepository announcementRepository = new AnnouncementRepository(uow);
return(new ContentService(articleRepository, siteNodeRepository, newsRepository, companyRepository, ideaRepository,
commentRepository, vacancyRepository, announcementRepository, uow, HttpContext.Current));
}
public void EFUnitOfWorkTests_GetAirport_ShouldReturnAnAirportWhenAirportIdExistsInDatabase()
{
// Arrange
var context = new EFUnitOfWork(_contextBuilder.Options);
// Expected
var expectedAirport = _airportsRecords.First();
// Act
var currentAirport = context.CreateSet <Airport>().Find(expectedAirport.Id);
// Assert
Check.That(currentAirport).IsNotNull();
Check.That(currentAirport).HasFieldsWithSameValues(expectedAirport);
}
public void EF_ProductsAssociatedCategoryIsLoadedOnAccess()
{
using (var uow = new EFUnitOfWork(this.AuthenticationProvider, this.MessageProvider, this.EventDispatcher, this.Connection))
{
// For testing purposes, the in-memory Effort database has to be initialized at the beginning of each test
(new MonolithicRepository(uow)).Database.Initialize(true);
var repo = new ProductRepository(uow, this._configuration);
Product p = repo.Get <Product>().Where(x => x.Name == "Dove").FirstOrDefault();
Assert.IsNotNull(p.Category);
Assert.AreEqual("Soap", p.Category.Name);
}
}
public static void DemoEF()
{
// TODO 等待完成
ApplicationDbContext context = null;
// 可以使用DI注入
using (var uow = new EFUnitOfWork(context))
{
// 等待完成
// uow.GetRepository<>
uow.Save();
}
}
public void StopOrder(int orderId, int?endSpotId)
{
using (database = new EFUnitOfWork(connectionName))
{
var order = database.Orders.Get(orderId);
if (order.EndDateTime != null || order.EndSpotId != null)
{
throw new InvalidOperationException("Заказ уже был завершен ранее");
}
order.EndSpotId = endSpotId;
order.EndDateTime = System.DateTime.Now;
order.Pizza.SpotId = endSpotId;
database.Save();
}
}
public void addingUser()
{
EFUnitOfWork unitOfWork = new EFUnitOfWork();
User obj = new User {
Name = "sec", Password = "******"
};
unitOfWork.Users.Create(obj);
var u2 = unitOfWork.Users.
Find(u => u.Name == "sec" && u.Password == "123").GetEnumerator();
u2.MoveNext();
Assert.AreEqual(obj.Name + obj.Password, u2.Current.Name + obj.Password);
unitOfWork.Users.Delete(obj.Id);
}
static void Main(string[] args)
{
DataContext dataContext = new DataContext();
IUnitOfWork unitOfWork = new EFUnitOfWork(dataContext);
IMarketerServices marketerServices = new MarketerServices(unitOfWork);
MarketerController marketerController = new MarketerController(marketerServices);
View view = new View(marketerController);
while (true)
{
view.MakeAction();
}
}
static void Main(string[] args)
{
//using (var data = new DataContext())
//{
//}
WebConfigRepository wr = new WebConfigRepository();
EFUnitOfWork ef = new EFUnitOfWork();
wr.UnitOfWork = ef;
wr.Add(new Model.WebConfig()
{
IsInitialed = true
});
ef.Commit();
}
private void InitializeDb()
{
using (var unitOfWork = new EFUnitOfWork(dbOptions))
{
var userRepository = unitOfWork.UserRepository;
userRepository.Add(new User
{
Name = "Test",
Surname = "Passed",
Email = userEmail,
Password = "******"
});
unitOfWork.Save();
}
}
public ObservableCollection <SpotViewModel> GetVacantSpots()
{
var mapper = AutoMapperConfigs.SpotToSpotVM.CreateMapper();
using (database = new EFUnitOfWork(connectionName))
{
//return mapper.Map<ObservableCollection<SpotViewModel>>(database
// .Spots.GetAll().Where(s => (s.Capacity - s.Pizzas.Count) > 0));
//Если делать по нормальному, то:
//InvalidOperationException: Существует назначенный этой команде Command открытый DataReader,
//который требуется предварительно закрыть
return(mapper.Map <ObservableCollection <SpotViewModel> >(database
.Spots
.Find(s => ((s.Capacity - s.Pizzas.Count) > 0))));
}
}
public void Dispose_disposes_all_open_IEFSession_instances()
{
var resolver = MockRepository.GenerateMock<IEFSessionResolver>();
resolver.Stub(x => x.GetSessionKeyFor<string>()).Return(Guid.NewGuid());
resolver.Stub(x => x.GetSessionKeyFor<int>()).Return(Guid.NewGuid());
resolver.Stub(x => x.OpenSessionFor<string>()).Return(MockRepository.GenerateStub<IEFSession>());
resolver.Stub(x => x.OpenSessionFor<int>()).Return(MockRepository.GenerateStub<IEFSession>());
var unitOfWork = new EFUnitOfWork(resolver);
unitOfWork.GetSession<string>();
unitOfWork.GetSession<int>();
unitOfWork.Dispose();
resolver.OpenSessionFor<string>().AssertWasCalled(x => x.Dispose());
resolver.OpenSessionFor<int>().AssertWasCalled(x => x.Dispose());
}
public MA_PCCF_CONFIG CreateConfig(SessionInfo sessioninfo, MA_PCCF_CONFIG data)
{
using (EFUnitOfWork unitOfWork = new EFUnitOfWork())
{
var checkDuplicate = unitOfWork.MA_PCCF_CONFIGRepository.GetAll().FirstOrDefault(p => p.LABEL.ToLower().Equals(data.LABEL.ToLower()));
if (checkDuplicate != null)
{
throw this.CreateException(new Exception(), Messages.DUPLICATE_DATA);
}
unitOfWork.MA_PCCF_CONFIGRepository.Add(data);
unitOfWork.Commit();
}
return(data);
}
public void Flush_calls_SubmitChanges_on_all_open_IEFSession_instances()
{
var resolver = MockRepository.GenerateMock<IEFSessionResolver>();
resolver.Stub(x => x.GetSessionKeyFor<string>()).Return(Guid.NewGuid());
resolver.Stub(x => x.GetSessionKeyFor<int>()).Return(Guid.NewGuid());
resolver.Stub(x => x.OpenSessionFor<string>()).Return(MockRepository.GenerateStub<IEFSession>());
resolver.Stub(x => x.OpenSessionFor<int>()).Return(MockRepository.GenerateStub<IEFSession>());
var unitOfWork = new EFUnitOfWork(resolver);
unitOfWork.GetSession<string>();
unitOfWork.GetSession<int>();
unitOfWork.Flush();
resolver.OpenSessionFor<string>().AssertWasCalled(x => x.SaveChanges());
resolver.OpenSessionFor<int>().AssertWasCalled(x => x.SaveChanges());
}
public MA_CONFIG_ATTRIBUTE CreateFactor(SessionInfo sessioninfo, MA_CONFIG_ATTRIBUTE factor)
{
using (EFUnitOfWork unitOfWork = new EFUnitOfWork())
{
var checkDuplicate = unitOfWork.MA_CONFIG_ATTRIBUTERepository.GetAll().FirstOrDefault(p => p.PCCF_CONFIG_ID == factor.PCCF_CONFIG_ID && p.TABLE == factor.TABLE && p.ATTRIBUTE == factor.ATTRIBUTE && p.ISACTIVE);
if (checkDuplicate != null)
{
throw this.CreateException(new Exception(), Messages.DUPLICATE_DATA);
}
unitOfWork.MA_CONFIG_ATTRIBUTERepository.Add(factor);
unitOfWork.Commit();
}
return(factor);
}
public void EFUnitOfWorkTests_ShouldNotFindAnyAircraftsRecords()
{
//Arrange && Expected
var context = new EFUnitOfWork(_contextBuilder.Options);
var aircraftCode = "AnyAircraft";
Expression <Func <Aircraft, bool> > filter = (Aircraft a) =>
(a.Code == aircraftCode);
// Act
var foundAircrafts = context.CreateSet <Aircraft>().Where(filter).ToList();
// Assert
Check.That(foundAircrafts).IsNotNull();
Check.That(foundAircrafts).IsEmpty();
}
public void CanDeleteCrop()
{
using (var db = new EFUnitOfWork())
{
var crop = db.Crops.Get().FirstOrDefault();
if (crop != null)
{
db.Crops.Remove(crop);
}
else
{
throw new Exception("Нет ни одного объекта crop");
}
db.Save();
}
}
public void GetSessionFor_returns_different_session_for_types_handled_by_different_context()
{
var resolver = MockRepository.GenerateMock<IEFSessionResolver>();
resolver.Stub(x => x.GetSessionKeyFor<string>()).Return(Guid.NewGuid());
resolver.Stub(x => x.GetSessionKeyFor<int>()).Return(Guid.NewGuid());
resolver.Stub(x => x.OpenSessionFor<string>()).Return(MockRepository.GenerateStub<IEFSession>());
resolver.Stub(x => x.OpenSessionFor<int>()).Return(MockRepository.GenerateStub<IEFSession>());
var unitOfWork = new EFUnitOfWork(resolver);
var stringSession = unitOfWork.GetSession<string>();
var intSession = unitOfWork.GetSession<int>();
Assert.That(stringSession, Is.Not.SameAs(intSession));
resolver.AssertWasCalled(x => x.GetSessionKeyFor<string>());
resolver.AssertWasCalled(x => x.GetSessionKeyFor<int>());
resolver.AssertWasCalled(x => x.OpenSessionFor<string>());
resolver.AssertWasCalled(x => x.OpenSessionFor<int>());
}
public void Can_get_orders_by_filter()
{
try
{
using (var c = new DataContainer(DbConnectionHelper.GetConnectionString()))
{
var g = new EFUnitOfWork(c);
var rep = new OrderRepository(g);
Order result = rep.First(d => d.Id > 0);
}
}
catch (Exception ex)
{
throw;
}
}
public void Dispose_disposes_all_open_IEFSession_instances()
{
var resolver = new Mock<IEFSessionResolver>();
resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
resolver.Setup(x => x.GetSessionKeyFor<int>()).Returns(Guid.NewGuid());
var session = new Mock<IEFSession>();
resolver.Setup(x => x.OpenSessionFor<string>()).Returns(session.Object);
resolver.Setup(x => x.OpenSessionFor<int>()).Returns(session.Object);
var unitOfWork = new EFUnitOfWork(resolver.Object);
unitOfWork.GetSession<string>();
unitOfWork.GetSession<int>();
unitOfWork.Dispose();
resolver.Object.OpenSessionFor<string>();
session.Verify(x => x.Dispose());
session.Verify(x => x.Dispose());
}
public void GetSessionFor_returns_different_session_for_types_handled_by_different_context()
{
var resolver = new Mock<IEFSessionResolver>();
resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
resolver.Setup(x => x.GetSessionKeyFor<int>()).Returns(Guid.NewGuid());
resolver.Setup(x => x.OpenSessionFor<string>()).Returns(new Mock<IEFSession>().Object);
resolver.Setup(x => x.OpenSessionFor<int>()).Returns(new Mock<IEFSession>().Object);
var unitOfWork = new EFUnitOfWork(resolver.Object);
var stringSession = unitOfWork.GetSession<string>();
var intSession = unitOfWork.GetSession<int>();
Assert.AreNotSame(stringSession, intSession);
resolver.Verify(x => x.GetSessionKeyFor<string>());
resolver.Verify(x => x.GetSessionKeyFor<int>());
resolver.Verify(x => x.OpenSessionFor<string>());
resolver.Verify(x => x.OpenSessionFor<int>());
}
public void Flush_calls_SubmitChanges_on_all_open_IEFSession_instances()
{
var resolver = new Mock<IEFSessionResolver>();
resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
resolver.Setup(x => x.GetSessionKeyFor<int>()).Returns(Guid.NewGuid());
var session = new Mock<IEFSession>();
resolver.Setup(x => x.OpenSessionFor<string>()).Returns(session.Object);
resolver.Setup(x => x.OpenSessionFor<int>()).Returns(session.Object);
var unitOfWork = new EFUnitOfWork(resolver.Object);
unitOfWork.GetSession<string>();
unitOfWork.GetSession<int>();
unitOfWork.Flush();
resolver.Object.OpenSessionFor<string>();
session.Verify(x => x.SaveChanges());
resolver.Object.OpenSessionFor<int>();
session.Verify(x => x.SaveChanges());
}
public override string[] GetRolesForUser(string username)
{
var efUnitOfWork = new EFUnitOfWork();
var adminRepos = new administratorsRepository(new EFRepository<administrators>(), efUnitOfWork);
var adminUser = adminRepos.GetByUsername(username);
if (adminUser != null)
{
return new string[] { CustomRoles.Admin.ToString() };
}else
{
var lecurerRepos = new lecturersRepository(new EFRepository<lecturers>(), efUnitOfWork);
var lecturerUser = lecurerRepos.GetByUsername(username);
if(lecturerUser!=null)
{
return new string[] { CustomRoles.Lecturer.ToString() };
}
}
return new string[] { CustomRoles.Student.ToString() };
}
public void BeginTransaction_Should_Start_A_New_Transaction_With_Specified_IsolatinLevel()
{
var isoLevel = IsolationLevel.Snapshot;
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateStub<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(isoLevel)).Return(mockTransaction);
var unitOfWork = new EFUnitOfWork(mockDataContext);
Assert.That(!unitOfWork.IsInTransaction);
unitOfWork.BeginTransaction(IsolationLevel.Snapshot);
Assert.That(unitOfWork.IsInTransaction);
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void Begin_Transaction_Should_Start_A_New_Transaction_With_Default_IsolationLevel()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted)).Return(mockTransaction);
var unitOfWork = new EFUnitOfWork(mockDataContext);
Assert.That(!unitOfWork.IsInTransaction);
unitOfWork.BeginTransaction();
Assert.That(unitOfWork.IsInTransaction);
//mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void BeginTransaction_Throws_InvalidOperationException_When_Transaction_Already_Running()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments().Return(mockTransaction);
var unitOfWork = new EFUnitOfWork(mockDataContext);
unitOfWork.BeginTransaction();
Assert.That(unitOfWork.IsInTransaction);
Assert.Throws<InvalidOperationException>(() => unitOfWork.BeginTransaction());
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void Init()
{
eFUnitOfWork = new EFUnitOfWork(new DataContainer());
charterRepository = new CharterRepository(eFUnitOfWork);
}
public CharterOutRepository(EFUnitOfWork efUnitOfWork)
: base(efUnitOfWork)
{
}
public void TransactionalFlush_Starts_A_Transaction_With_Default_Isolation_And_Commits_When_Flush_Succeeds()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments()
.Return(mockTransaction);
mockDataContext.Expect(x => x.SaveChanges());
mockConnection.Expect(x => x.State).Return(ConnectionState.Closed); //First call should be closed
mockConnection.Expect(x => x.Open());
mockTransaction.Expect(x => x.Commit());
mockConnection.Expect(x => x.State).Return(ConnectionState.Open); //Second call should be open
mockConnection.Expect(x => x.Close());
var unitOfWork = new EFUnitOfWork(mockDataContext);
unitOfWork.TransactionalFlush();
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void TransactionalFlush_Rollsback_Transaction_When_Flush_Throws_Exception()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments()
.Return(mockTransaction);
mockDataContext.Expect(x => x.SaveChanges()).Throw(new Exception());
mockTransaction.Expect(x => x.Rollback());
var unitOfWork = new EFUnitOfWork(mockDataContext);
Assert.Throws<Exception>(unitOfWork.TransactionalFlush);
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void GetSessionFor_returns_session_for_type()
{
var resolver = new Mock<IEFSessionResolver>();
resolver.Setup(x => x.GetSessionKeyFor<string>()).Returns(Guid.NewGuid());
resolver.Setup(x => x.OpenSessionFor<string>()).Returns(new Mock<IEFSession>().Object);
var unitOfWork = new EFUnitOfWork(resolver.Object);
var session = unitOfWork.GetSession<string>();
Assert.IsNotNull(session);
}
public void TransactionalFlush_Starts_A_Transaction_With_Specified_IsolationLevel_And_Commits_When_Flush_Succeeds()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments()
.Return(mockTransaction);
mockDataContext.Expect(x => x.SaveChanges());
mockTransaction.Expect(x => x.Commit());
var unitOfWork = new EFUnitOfWork(mockDataContext);
unitOfWork.TransactionalFlush(IsolationLevel.ReadUncommitted);
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void Comitting_Transaction_Releases_Transaction_From_UnitOfWork()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Stub(x => x.Connection).Return(mockConnection);
mockConnection.Expect(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments()
.Return(mockTransaction);
mockTransaction.Expect(x => x.Commit());
var unitOfWork = new EFUnitOfWork(mockDataContext);
var transaction = unitOfWork.BeginTransaction();
Assert.That(unitOfWork.IsInTransaction);
transaction.Commit();
Assert.That(!unitOfWork.IsInTransaction);
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void TransactionalFlush_Uses_Existing_Transaction_When_Transactional_AlreadyRunning()
{
var mockDataContext = MockRepository.GenerateMock<IEFSession>();
var mockConnection = MockRepository.GenerateMock<IDbConnection>();
var mockTransaction = MockRepository.GenerateMock<IDbTransaction>();
mockDataContext.Expect(x => x.Connection).Repeat.Any().Return(mockConnection);
mockConnection.Stub(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments()
.Repeat.Once()
.Return(mockTransaction);
var unitOfWork = new EFUnitOfWork(mockDataContext);
unitOfWork.BeginTransaction();
unitOfWork.TransactionalFlush();
mockDataContext.VerifyAllExpectations();
mockConnection.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void Init()
{
eFUnitOfWork = new EFUnitOfWork(new DataContainer(DbConnectionHelper.GetConnectionString()));
charterInRepository = new CharterInRepository(eFUnitOfWork);
//Repository = new CharterRepository(eFUnitOfWork);
}
public EFTransaction(EFUnitOfWork uow)
{
_uow = uow;
_trans = uow.Context.Database.BeginTransaction();
}
public EFTransaction(EFUnitOfWork uow, System.Data.IsolationLevel level)
{
_uow = uow;
_trans = uow.Context.Database.BeginTransaction(level);
}
private void SetUpDatabase(int count)
{
DataUtil.CreateDatabase(TestConstants.EF_DatabaseName);
DataUtil.ExecuteNonQuery(TestConstants.EF_DatabaseName, TestConstants.EF_CreateTableSql);
for (int i = 0; i < count; i++)
{
var name = (i < _dogNames.Length) ? _dogNames[i] : String.Format("Name_{0}", i);
var age = (i < _dogNames.Length) ? _dogAges[i] : i.ToString();
DataUtil.ExecuteNonQuery(TestConstants.EF_DatabaseName, String.Format(TestConstants.EF_InsertRow, name, age));
}
_efUnitOfWork = CreateEFUnitOfWork();
}
public void Dispose()
{
_uow = null;
_trans.Dispose();
}
