public void BeginTransaction_Throws_InvalidOperationException_When_Transaction_Already_Running()
{
var mockSession = MockRepository.GenerateStub<ISession>();
mockSession.Stub(x => x.BeginTransaction(IsolationLevel.Unspecified))
.IgnoreArguments().Return(MockRepository.GenerateStub<ITransaction>());
var unitOfWork = new NHibernateUnitOfWork(mockSession);
unitOfWork.BeginTransaction();
unitOfWork.IsInTransaction.ShouldBeTrue();
Assert.Throws<InvalidOperationException>(() => { unitOfWork.BeginTransaction(); });
}
public void Comitting_Transaction_Releases_Transaction_From_UnitOfWork()
{
var mockSession = MockRepository.GenerateMock<ISession>();
mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
.Return(MockRepository.GenerateStub<ITransaction>());
var unitOfWork = new NHibernateUnitOfWork(mockSession);
Magnum.Data.ITransaction transaction = unitOfWork.BeginTransaction();
unitOfWork.IsInTransaction.ShouldBeTrue();
transaction.Commit();
unitOfWork.IsInTransaction.ShouldBeFalse();
mockSession.VerifyAllExpectations();
}
public void BeginTransaction_Should_Start_A_New_Transaction_With_Specified_IsolatinLevel()
{
var mockSession = MockRepository.GenerateMock<ISession>();
var mockTransaction = MockRepository.GenerateStub<ITransaction>();
mockSession.Expect(x => x.BeginTransaction(IsolationLevel.Snapshot))
.Return(mockTransaction);
var unitOfWork = new NHibernateUnitOfWork(mockSession);
unitOfWork.IsInTransaction.ShouldBeFalse();
unitOfWork.BeginTransaction(IsolationLevel.Snapshot);
unitOfWork.IsInTransaction.ShouldBeTrue();
mockSession.VerifyAllExpectations();
}
public void Start_CreatesNHibernateUnitOfWorkAndBeginsWithTwoTransaction() {
// Arrange
// Act
var unitOfWork = new NHibernateUnitOfWork(SessionFactory);
using (var unitOfWorkRootScope = unitOfWork.Start()) {
using (var unitOfWorkScope = unitOfWork.Start()) {
unitOfWorkScope.Rollback();
}
unitOfWorkRootScope.Commit();
}
// Assert
}
public void all_other_methods_should_throw_if_not_initialized()
{
_uow = new NHibernateUnitOfWork(_nHibernateSessionFactory);
var flags = BindingFlags.Public | BindingFlags.DeclaredOnly;
var exception = typeof(InvalidOperationException);
var methods = typeof(NHibernateUnitOfWork).GetMethods(flags).Where(m => m.Name != "Initialize" && m.Name != "Dispose");
methods.Each(m =>
{
var paramCount = m.GetParameters().Length;
var methodParams = new object[paramCount];
paramCount.IterateFromZero(idx => methodParams[idx] = null);
exception.ShouldBeThrownBy(() => m.Invoke(_uow, methodParams), m.Name);
});
}
public void Setup()
{
_cfg = new Configuration();
_cfg.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
_cfg.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
_cfg.SetProperty("connection.connection_string", _connectionString);
_cfg.SetProperty("dialect", "NHibernate.Dialect.MsSql2005Dialect");
_cfg.SetProperty("default_schema", "bus");
_cfg.AddAssembly(typeof(StateMachineStorage_Specs).Assembly);
ISessionFactory _sessionFactory = _cfg.BuildSessionFactory();
LocalContext.Current.Store(_sessionFactory);
NHibernateUnitOfWork.SetSessionProvider(() => LocalContext.Current.Retrieve <ISessionFactory>().OpenSession());
UnitOfWork.SetUnitOfWorkProvider(NHibernateUnitOfWork.Create);
}
private static void prepareGremio(Gremio gremio)
{
var direccion = gremio.Direccion;
saveDepartamentoMunicipio(direccion.Departamento, direccion.Municipio);
using (var uow = new NHibernateUnitOfWork(_sessionFactory.OpenSession()))
{
var representanteRepository = new RepresentanteLegalRepositoryReadOnly(uow.Session);
var direccionRepository = new DireccionRepositoryReadOnly(uow.Session);
var gremioRead = new GremioRepositoryReadOnly(uow.Session);
if (!gremioRead.exists(gremio.Id))
{
var gremioRepository = new GremioRepositoryCommands(uow.Session, representanteRepository,
direccionRepository);
gremioRepository.save(gremio);
uow.commit();
}
}
}
private static void prepareEmpresa(Empresa empresa)
{
var gremio = empresa.Gremial;
var sucursales = empresa.Sucursales;
var actividades = empresa.ActividadesEconomicas;
prepareGremio(gremio);
sucursales.ToList().ForEach(x => prepareUser(x.Firma.User));
actividades.ToList().ForEach(prepareActividades);
_session = _sessionFactory.OpenSession();
using (var uow = new NHibernateUnitOfWork(_sessionFactory.OpenSession()))
{
var repositoryGremios = new GremioRepositoryReadOnly(uow.Session);
var repository = new EmpresaRepositoryCommands(uow.Session, repositoryGremios);
repository.save(empresa);
uow.commit();
}
}
protected void Application_Start(object sender, EventArgs e)
{
XmlConfigurator.Configure();
_container = new DefaultMassTransitContainer(Server.MapPath("/web-castle.config"));
Configuration _cfg = new Configuration().Configure();
_cfg.AddAssembly(typeof(NHibernateRepositoryFactory).Assembly);
ISessionFactory _sessionFactory = _cfg.BuildSessionFactory();
LocalContext.Current.Store(_sessionFactory);
NHibernateUnitOfWork.SetSessionProvider(_sessionFactory.OpenSession);
UnitOfWork.SetUnitOfWorkProvider(NHibernateUnitOfWork.Create);
_container.Kernel.AddComponentInstance <IRepositoryFactory>(NHibernateRepositoryFactory.Configure(x => { }));
DomainContext.Initialize(_container.Resolve <IServiceBus>("client"), _container.Resolve <IObjectBuilder>());
}
static void Main(string[] args)
{
using (var session = NHibernateHelper.OpenSession())
{
//using (var uow = new NHibernateUnitOfWork())
//{
// var donorRep = new Repository<Donor>(uow.Session);
// var donationRep = new Repository<Donation>(uow.Session);
// var d = new Donor
// {
// CreatedOn = DateTime.Now,
// Name = "Joe Donor",
// Phone = "512-555-1212"
// };
// var dt = new Donation
// {
// Donor = d,
// Amount = 100.25m,
// CreatedOn = DateTime.Now,
// DateOfDonation = DateTime.Now
// };
// donorRep.Add(d);
// donationRep.Add(dt);
// uow.Commit();
//}
// Sample of fetching a row
using (var uow = new NHibernateUnitOfWork())
{
var donorRep = new Repository <Donor>(uow.Session);
var donors = donorRep.Select(x => x);
}
}
}
public void Flush_Calls_Underlying_ISession_Flush()
{
var mockSession = MockRepository.GenerateMock<ISession>();
mockSession.Expect(x => x.Flush());
var unitOfWork = new NHibernateUnitOfWork(mockSession);
unitOfWork.Flush();
mockSession.VerifyAllExpectations();
}
public BaseApiController()
{
MyUnitOfWork = (NHibernateUnitOfWork)MathClubTracker.MvcApplication.UnitOfWork;
MySession = MyUnitOfWork.Session;
_identityService = new IdentityService();
}
public NHibernateRepository(NHibernateUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
this.session = unitOfWork.Session;
}
public ClientRepository()
{
session = NHibernateHelper<Client>.OpenSession();
session.FlushMode = FlushMode.Commit;
nHibernateUnitOfWork = new NHibernateUnitOfWork(session.BeginTransaction());
}
public SearchForLibraryModule(NHibernateUnitOfWork unitOfWork, IMessageHandler <SearchForLibrary> messageHandler)
: base(unitOfWork, messageHandler, "/libraries/{searchstring}")
{
}
public AddBookModule(EventStoreUnitOfWork unitOfWork, ICommandHandler <AddBookToLibrary> commandHandler,
NHibernateUnitOfWork relationalUnitOfWork, EventDispatcher eventDispatcher)
: base(unitOfWork, commandHandler, "/libraries/{AggregateId}/books/add", relationalUnitOfWork,
eventDispatcher)
{
}
public void TransactionalFlush_Starts_A_Transaction_With_Specified_IsolationLevel_And_Commits_When_Flush_Succeeds()
{
var mockSession = MockRepository.GenerateMock<ISession>();
var mockTransaction = MockRepository.GenerateMock<ITransaction>();
mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadUncommitted))
.Return(mockTransaction);
mockSession.Expect(x => x.Flush());
mockTransaction.Expect(x => x.Commit());
var unitOfWork = new NHibernateUnitOfWork(mockSession);
unitOfWork.Commit(IsolationLevel.ReadUncommitted);
mockSession.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void SetUp()
{
UnitOfWork = new NHibernateUnitOfWork(NHibernateSessionProvider.SessionFactory.OpenSession());
svc = new StudentService(UnitOfWork.Session);
}
public RemoveBookModule(EventStoreUnitOfWork unitOfWork, ICommandHandler <RemoveBookFromLibrary> commandHandler,
NHibernateUnitOfWork relationalUnitOfWork, EventDispatcher eventDispatcher)
: base(unitOfWork, commandHandler, "/libraries/{AggregateId}/books/remove", relationalUnitOfWork,
eventDispatcher)
{
}
protected GenericNHibernateRepository(NHibernateUnitOfWork unitOfWork)
{
UnitOfWork = unitOfWork;
}
private void StartNewUnitOfWork()
{
unitOfWork = (NHibernateUnitOfWork)UnitOfWork.Start();
userRepository = new NHibernateRepository <UserModel, int>(unitOfWork);
}
public OrderRepository(ISession session)
{
Context = new NHibernateUnitOfWork(session);
}
public void IsInTransaction_Should_Return_False_When_No_Transaction_Exists()
{
var mockSession = MockRepository.GenerateStub<ISession>();
var unitOfWork = new NHibernateUnitOfWork(mockSession);
unitOfWork.IsInTransaction.ShouldBeFalse();
}
public void Throw_If_Session_Is_Null()
{
var uow = new NHibernateUnitOfWork(null);
}
public void TransactionalFlush_Rollsback_Transaction_When_Flush_Throws_Exception()
{
var mockSession = MockRepository.GenerateMock<ISession>();
var mockTransaction = MockRepository.GenerateMock<ITransaction>();
mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
.Return(mockTransaction);
mockSession.Expect(x => x.Flush()).Throw(new Exception());
mockTransaction.Expect(x => x.Rollback());
var unitOfWork = new NHibernateUnitOfWork(mockSession);
Assert.Throws<Exception>(() => { unitOfWork.Commit(); });
mockSession.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void SetUp()
{
_nHibernateSessionFactory = MockRepository.GenerateStub<INHibernateSessionFactory>();
_session = MockRepository.GenerateMock<ISession>();
_transaction = MockRepository.GenerateStub<ITransaction>();
_nHibernateSessionFactory.Stub(s => s.CreateSession()).Return(_session);
_session.Stub(s => s.BeginTransaction()).Return(_transaction);
_uow = new NHibernateUnitOfWork(_nHibernateSessionFactory);
_uow.Initialize();
}
public void TransactionalFlush_Uses_Existing_Transaction_When_Transactional_AlreadyRunning()
{
var mockSession = MockRepository.GenerateMock<ISession>();
var mockTransaction = MockRepository.GenerateMock<ITransaction>();
mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
.Return(mockTransaction)
.Repeat.Once(); //Expect BeginTransaction to be called only once.
var unitOfWork = new NHibernateUnitOfWork(mockSession);
unitOfWork.BeginTransaction();
unitOfWork.Commit();
mockSession.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public void Teardown()
{
NHibernateUnitOfWork.SetSessionProvider(null);
LocalContext.Current.Clear();
}
public AcceptLinkModule(EventStoreUnitOfWork unitOfWork, ICommandHandler <AcceptLink> commandHandler,
NHibernateUnitOfWork relationalUnitOfWork, EventDispatcher eventDispatcher)
: base(unitOfWork, commandHandler, "/libraries/{AggregateId}/links/accept/", relationalUnitOfWork,
eventDispatcher)
{
}
public SomeClass(IConfigurationRoot configuration)
{
NHibernateUnitOfWork.Init(Configuration["ConnectionStrings:OracleConnection"]);
}
public void Dispose_UnitOfWork_Disposed_Underlying_Transaction_And_Session()
{
var mockSession = MockRepository.GenerateMock<ISession>();
var mockTransaction = MockRepository.GenerateMock<ITransaction>();
mockSession.Expect(x => x.BeginTransaction(IsolationLevel.ReadCommitted))
.Return(mockTransaction);
mockTransaction.Expect(x => x.Dispose());
mockSession.Expect(x => x.Dispose());
using (var unitOfWork = new NHibernateUnitOfWork(mockSession))
{
unitOfWork.BeginTransaction();
}
mockSession.VerifyAllExpectations();
mockTransaction.VerifyAllExpectations();
}
public SearchForBookModule(NHibernateUnitOfWork unitOfWork, IAuthenticatedQueryHandler <SearchForBook> queryHandler)
: base(unitOfWork, queryHandler, "/books/{SearchString}")
{
}
private void StartNewUnitOfWork()
{
unitOfWork = (NHibernateUnitOfWork)UnitOfWork.Start();
qrCodeRepository = new NHibernateRepository <QrCodeModel, string>(unitOfWork);
}
public ListLibrariesModule(NHibernateUnitOfWork unitOfWork, IAuthenticatedQueryHandler <ListLibraries> messageHandler)
: base(unitOfWork, messageHandler, "/libraries/")
{
}
public void Valid_course_crud()
{
var appsettings = Config.InitConfiguration();
var unitOfWork = NHibernateUnitOfWork.Create(appsettings.GetSection("Database")["ConnectionSrtring"]);
var authorId = Guid.NewGuid();
var courseId = Guid.NewGuid();
unitOfWork.BeginUnit();
var authors = unitOfWork.GetAuthorRepository();
var courses = unitOfWork.GetCourseRepository();
var author = Author.Create(authorId, "Marcos Harbs", "");
var course = Course.Create(courseId, "Curso de JS", "Curso básico de desenvolvimento javascript", author);
var video1 = Video.Create("Video 1", "http://youtube.com/video1");
var video2 = Video.Create("Video 2", "http://youtube.com/video2");
course.AddVideo(video1);
course.AddVideo(video2);
authors.AddOrUpdate(author);
courses.AddOrUpdate(course);
var courseDb = courses.GetById(courseId);
courseDb.Id.Should().Be(course.Id);
courseDb.Videos.Count().Should().Be(course.Videos.Count());
unitOfWork.CommitUnit();
unitOfWork.BeginUnit();
authors = unitOfWork.GetAuthorRepository();
courses = unitOfWork.GetCourseRepository();
course = courses.GetById(courseId);
course.RemoveVideos();
course.AddVideo(Video.Create("Video 3", "http://youtube.com/video1"));
courses.AddOrUpdate(course);
courseDb = courses.GetById(courseId);
courseDb.Id.Should().Be(course.Id);
courseDb.CourseName.Should().Be(course.CourseName);
courseDb.Videos.Count().Should().Be(course.Videos.Count());
var coursesCount = courses.Count();
coursesCount.Should().Be(1);
var allCourses = courses.GetAll();
var partialCourses = courses.GetPartial(0, 20);
allCourses.Count.Should().Be(1);
partialCourses.Count.Should().Be(1);
allCourses.ToList()[0].Should().Be(courseDb);
partialCourses.ToList()[0].Should().Be(courseDb);
unitOfWork.CommitUnit();
unitOfWork.BeginUnit();
authors = unitOfWork.GetAuthorRepository();
courses = unitOfWork.GetCourseRepository();
courses.Remove(courseDb);
authors.Remove(author);
unitOfWork.CommitUnit();
}
public ListRequestedLinksModule(NHibernateUnitOfWork unitOfWork, IAuthenticatedQueryHandler <ListRequestedLinks> queryHandler)
: base(unitOfWork, queryHandler, "/libraries/{AggregateId}/links/sent")
{
}
public ListLibraryBooksModule(NHibernateUnitOfWork unitOfWork, IAuthenticatedQueryHandler <ListLibraryBooks> queryHandler)
: base(unitOfWork, queryHandler, "/libraries/{AggregateId}/books/")
{
}
public OpenLibraryModule(EventStoreUnitOfWork unitOfWork, ICommandHandler <OpenLibrary> commandHandler,
NHibernateUnitOfWork relationalUnitOfWork, EventDispatcher eventDispatcher)
: base(unitOfWork, commandHandler, "/libraries/", relationalUnitOfWork,
eventDispatcher)
{
}
public BaseODataController()
{
MyUnitOfWork = (NHibernateUnitOfWork)MathClubTracker.MvcApplication.UnitOfWork;
MySession = MyUnitOfWork.Session;
}
public void Setup()
{
Lifecycle.Current = new IntegrationTestLifecycle();
_repo = ObjectContainer.Get <BMRepo>();
_unitOfWork = ObjectContainer.Get <NHibernateUnitOfWork>();
}
private void StartNewUnitOfWork()
{
unitOfWork = (NHibernateUnitOfWork)UnitOfWork.Start();
productRepository = new NHibernateRepository <ProductModel, string>(unitOfWork);
}
public AuthCallbackProvider(IUserMapper userMapper, NHibernateUnitOfWork unitOfWork, Tokeniser tokeniser)
{
this.userMapper = userMapper;
this.unitOfWork = unitOfWork;
this.tokeniser = tokeniser;
}
public void SetUp()
{
mocks = new MockRepository();
factory = mocks.DynamicMock<ISessionFactory>();
session = mocks.DynamicMock<ISession>();
transaction = mocks.DynamicMock<ITransaction>();
sessionFactoryFunc = () => factory;
unitOfWork = mocks.Stub<NHibernateUnitOfWork>(sessionFactoryFunc);
}
public async Task Invoke(IDictionary <string, object> environment)
{
using (IUnitOfWork uow = new NHibernateUnitOfWork(SessionManager <WebSessionContext> .Current))
await _next.Invoke(environment);
}
