public async Task ClaimLock_Given_Scope_Gives_ReturnItem()
        {
            var createItem = new TestItemBare
            {
                Value = "x"
            };
            var item = await _table.CreateAndReturnAsync(createItem);

            Assert.IsNotNull(item);

            bool?lockSuccess = null;

            using (var scope = CreateStandardScope())
            {
                try
                {
                    var lockedItem = await _table.SearchSingleAndLockWhereAsync("Id=@Id", new { Id = item.Id });

                    FulcrumAssert.IsNotNull(lockedItem);
                    lockSuccess = true;
                    scope.Complete();
                }
                catch (Exception)
                {
                    lockSuccess = false;
                }
            }
            Assert.IsNotNull(lockSuccess);
            Assert.IsTrue(lockSuccess);
        }
Esempio n. 2
0
        public async Task Update_NotFound_Async()
        {
            var updateItem = new TestItemBare();

            updateItem.InitializeWithDataForTesting(TypeOfTestDataEnum.Default);
            await CrudStorage.UpdateAsync(CrudHelper.CreateNewId <TId>(), updateItem);

            Assert.Fail("Expected an exception");
        }
        public async Task CreateAndReturn_Async()
        {
            var initialItem = new TestItemBare();

            initialItem.InitializeWithDataForTesting(TypeOfTestDataEnum.Default);
            var createdItem = await CrdStorage.CreateAndReturnAsync(initialItem);

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(createdItem);
            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(initialItem, createdItem);
        }
        public async Task TestWithDefaultId()
        {
            var item = new TestItemBare();

            item.InitializeWithDataForTesting(TypeOfTestDataEnum.Default);
            await ExpectContractExceptionAsync(async() =>
                                               await _implementation.CreateWithSpecifiedIdAsync(Guid.Empty, item),
                                               "CreateWithSpecifiedIdAsync(Guid.Empty, item)");
            await ExpectContractExceptionAsync(async() =>
                                               await _implementation.CreateWithSpecifiedIdAndReturnAsync(Guid.NewGuid(), null),
                                               "CreateWithSpecifiedIdAndReturnAsync(Guid.Empty, item)");
        }
        public async Task MessageGetsThrough()
        {
            var message = new TestItemBare();

            message.InitializeWithDataForTesting(TypeOfTestDataEnum.Variant1);
            await Queue.AddMessageAsync(message);

            var result = await Queue.GetOneMessageNoBlockAsync();

            Assert.IsNotNull(result);
            Assert.AreEqual(message, result);
        }
        public async Task CreateAndReturn_Read_Etag_Async()
        {
            var initialItem = new TestItemBare();

            initialItem.InitializeWithDataForTesting(TypeOfTestDataEnum.Default);
            var createdItem = await CrdStorage.CreateAndReturnAsync(initialItem);

            Assert.IsNotNull(createdItem);
            Assert.AreNotEqual(createdItem.Id, default);
            Assert.IsNotNull(createdItem.Etag);
            Assert.AreEqual(initialItem, createdItem);
        }
        public async Task Create_Read_Async()
        {
            var initialItem = new TestItemBare();

            initialItem.InitializeWithDataForTesting(TypeOfTestDataEnum.Default);
            var id = await CrdStorage.CreateAsync(initialItem);

            var createdItem = await CrdStorage.ReadAsync(id);

            Assert.IsNotNull(createdItem);
            Assert.AreEqual(initialItem, createdItem);
        }
        public async Task ClaimLock_Given_ItemExists_Gives_ReturnItem()
        {
            var createItem = new TestItemBare
            {
                Value = "x"
            };
            var item = await _table.CreateAndReturnAsync(createItem);

            Assert.IsNotNull(item);

            var lockedItem = await _table.SearchSingleAndLockWhereAsync("Id=@Id", new { Id = item.Id });

            Assert.IsNotNull(lockedItem);
        }
        public async Task ClaimLock_Given_AlreadyLocked_Gives_FulcrumTryAgainException()
        {
            var createItem = new TestItemBare
            {
                Value = "x"
            };
            var item = await _table.CreateAndReturnAsync(createItem);

            Assert.IsNotNull(item);
            bool?lock2Success = null;

            var claimLock1Success    = new ManualResetEvent(false);
            var hasTriedToClaimLock2 = new ManualResetEvent(false);
            var thread1 = ThreadHelper.FireAndForget(async() =>
            {
                using (var scope = CreateStandardScope())
                {
                    var lockedItem = await _table.SearchSingleAndLockWhereAsync("Id=@Id", new { Id = item.Id });
                    FulcrumAssert.IsNotNull(lockedItem);
                    claimLock1Success.Set();
                    FulcrumAssert.IsTrue(hasTriedToClaimLock2.WaitOne(TimeSpan.FromSeconds(1)), CodeLocation.AsString());
                    scope.Complete();
                }
            });
            var thread2 = ThreadHelper.FireAndForget(async() =>
            {
                FulcrumAssert.IsTrue(claimLock1Success.WaitOne(TimeSpan.FromSeconds(1)));
                using (var scope = CreateStandardScope())
                {
                    try
                    {
                        var lockedItem = await _table.SearchSingleAndLockWhereAsync("Id=@Id", new { Id = item.Id });
                        FulcrumAssert.IsNotNull(lockedItem);
                        lock2Success = true;
                        scope.Complete();
                    }
                    catch (FulcrumTryAgainException)
                    {
                        lock2Success = false;
                    }
                }
                hasTriedToClaimLock2.Set();
            });

            Assert.IsTrue(thread2.Join(TimeSpan.FromSeconds(5)));
            Assert.IsNotNull(lock2Success);
            Assert.IsFalse(lock2Success);
            Assert.IsTrue(thread1.Join(TimeSpan.FromSeconds(1)));
        }
        public async Task ClearQueue()
        {
            var message = new TestItemBare();

            message.InitializeWithDataForTesting(TypeOfTestDataEnum.Variant1);
            await Queue.AddMessageAsync(message);

            await Queue.ClearAsync();

            var getTask = Queue.GetOneMessageNoBlockAsync();
            await Task.Delay(TimeSpan.FromMilliseconds(100));

            Assert.IsTrue(getTask.IsCompleted, "Expected the method to finish quickly.");
            Assert.IsNull(await getTask);
        }
        public async Task Delete_Async()
        {
            var initialItem = new TestItemBare();

            initialItem.InitializeWithDataForTesting(TypeOfTestDataEnum.Default);
            var id = await CrdStorage.CreateAsync(initialItem);

            await CrdStorage.ReadAsync(id);

            await CrdStorage.DeleteAsync(id);

            var item = await CrdStorage.ReadAsync(id);

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNull(item);
        }
Esempio n. 12
0
        public async Task PeekAndGet()
        {
            var message = new TestItemBare();

            message.InitializeWithDataForTesting(TypeOfTestDataEnum.Variant1);
            await Queue.AddMessageAsync(message);

            var result = await Queue.PeekNoBlockAsync();

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(result);
            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(message, result);
            result = await Queue.GetOneMessageNoBlockAsync();

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(result);
            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(message, result);
        }