Пример #1
0
            public void ShouldDelegateToAsyncTransaction()
            {
                var asyncTxc = new Mock <IInternalAsyncTransaction>();
                var rxTxc    = new InternalRxTransaction(asyncTxc.Object);

                var config = rxTxc.TransactionConfig;

                asyncTxc.Verify(x => x.TransactionConfig, Times.Once);
            }
Пример #2
0
            public void ShouldInvokeTxcCommitAsync()
            {
                var asyncTxc = new Mock <IInternalAsyncTransaction>();
                var rxTxc    = new InternalRxTransaction(asyncTxc.Object);

                var commit = rxTxc.Commit <Unit>();

                asyncTxc.Verify(x => x.CommitAsync(), Times.Never);

                commit.WaitForCompletion();

                asyncTxc.Verify(x => x.CommitAsync(), Times.Once);
            }
Пример #3
0
            public void ShouldInvokeTxcRollbackAsync()
            {
                var asyncTxc = new Mock <IInternalAsyncTransaction>();
                var rxTxc    = new InternalRxTransaction(asyncTxc.Object);

                var rollback = rxTxc.Rollback <Unit>();

                asyncTxc.Verify(x => x.RollbackAsync(), Times.Never);

                rollback.WaitForCompletion();

                asyncTxc.Verify(x => x.RollbackAsync(), Times.Once);
            }
Пример #4
0
            private static void VerifyLazyRunAsync(Action <IRxResult> action)
            {
                var asyncTxc = new Mock <IInternalAsyncTransaction>();

                asyncTxc.Setup(x => x.RunAsync(It.IsAny <Query>()))
                .ReturnsAsync(new ListBasedRecordCursor(new[] { "x" }, Enumerable.Empty <IRecord>,
                                                        Mock.Of <IResultSummary>));
                var txc    = new InternalRxTransaction(asyncTxc.Object);
                var result = txc.Run("RETURN 1");

                asyncTxc.Verify(
                    x => x.RunAsync(It.IsAny <Query>()), Times.Never);

                action(result);

                asyncTxc.Verify(
                    x => x.RunAsync(It.IsAny <Query>()), Times.Once);
            }
Пример #5
0
            public void ShouldReturnInternalRxResult()
            {
                var rxTxc = new InternalRxTransaction(Mock.Of <IInternalAsyncTransaction>());

                rxTxc.Run("RETURN 1").Should().BeOfType <RxResult>();
            }