Beispiel #1
0
        public async Task SearchNestedOrderBy_Async()
        {
            // Arrange
            TestItemBare.Modulo = 2;
            TestItemBare.Count  = 1;
            await CreateItemAsync(TypeOfTestDataEnum.Variant1); // 1, 1
            await CreateItemAsync(TypeOfTestDataEnum.Variant2); // 2, 0
            await CreateItemAsync(TypeOfTestDataEnum.Variant2); // 3, 1
            await CreateItemAsync(TypeOfTestDataEnum.Variant2); // 4, 0
            await CreateItemAsync(TypeOfTestDataEnum.Variant2); // 5, 1

            // Act
            var search = CrudStorage as ISearch <TestItemSort <TId>, TId>;

            Assert.IsNotNull(search, $"{CrudStorage.GetType().Name} was expected to implement {nameof(ISearch<TestItemSort<TId>, TId>)}");

            var searchDetails = new SearchDetails <TestItemSort <TId> >(new { Value = "Variant2" }, new { NumberModulo = true, IncreasingNumber = false });
            var page          = await search.SearchAsync(searchDetails, 0, 10);

            // Assert
            Assert.AreEqual(4, page.PageInfo.Returned);
            var array = page.Data.ToArray();

            Assert.AreEqual(0, array[0].NumberModulo);
            Assert.AreEqual(4, array[0].IncreasingNumber);
            Assert.AreEqual(0, array[1].NumberModulo);
            Assert.AreEqual(2, array[1].IncreasingNumber);
            Assert.AreEqual(1, array[2].NumberModulo);
            Assert.AreEqual(5, array[2].IncreasingNumber);
            Assert.AreEqual(1, array[3].NumberModulo);
            Assert.AreEqual(3, array[3].IncreasingNumber);
        }
Beispiel #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");
        }
Beispiel #3
0
        public async Task SearchOrderBy_Async(string value, bool orderByNumber, bool ascending)
        {
            // Arrange
            await CreateItemAsync(TypeOfTestDataEnum.Variant1);
            await CreateItemAsync(TypeOfTestDataEnum.Variant2);
            await CreateItemAsync(TypeOfTestDataEnum.Variant1);
            await CreateItemAsync(TypeOfTestDataEnum.Variant2);
            await CreateItemAsync(TypeOfTestDataEnum.NullValue);

            // Act
            var search = CrudStorage as ISearch <TestItemSort <TId>, TId>;

            Assert.IsNotNull(search, $"{CrudStorage.GetType().Name} was expected to implement {nameof(ISearch<TestItemSort<TId>, TId>)}");
            PageEnvelope <TestItemSort <TId> > page;

            if (orderByNumber)
            {
                var searchDetails = new SearchDetails <TestItemSort <TId> >(new { Value = value }, new { IncreasingNumber = ascending });
                page = await search.SearchAsync(searchDetails, 0, 10);
            }
            else
            {
                var searchDetails = new SearchDetails <TestItemSort <TId> >(new { Value = value }, new { DecreasingString = @ascending });
                page = await search.SearchAsync(searchDetails, 0, 10);
            }



            // Assert
            Assert.AreEqual(2, page.PageInfo.Returned);
            var array = page.Data.ToArray();

            if (orderByNumber)
            {
                if (ascending)
                {
                    Assert.IsTrue(array[0].IncreasingNumber < array[1].IncreasingNumber);
                }
                else
                {
                    Assert.IsTrue(array[0].IncreasingNumber > array[1].IncreasingNumber);
                }
            }
            else
            {
                if (ascending)
                {
                    Assert.IsTrue(string.Compare(array[0].DecreasingString, array[1].DecreasingString, StringComparison.InvariantCulture) == -1);
                }
                else
                {
                    Assert.IsTrue(string.Compare(array[0].DecreasingString, array[1].DecreasingString, StringComparison.InvariantCulture) == 1);
                }
            }
        }
Beispiel #4
0
        public async Task Update_ValidationFailed_Async()
        {
            var id = await CreateItemAsync(TypeOfTestDataEnum.Default);

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreNotEqual(default(TId), id);
            var updatedItem = new TestItemValidated <TId>();

            updatedItem.InitializeWithDataForTesting(TypeOfTestDataEnum.ValidationFail);
            await CrudStorage.UpdateAsync(id, updatedItem);

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.Fail($"Expected the method {nameof(CrudStorage.UpdateAsync)} to detect that the data was not valid and throw the exception {nameof(FulcrumContractException)}.");
        }
Beispiel #5
0
        public async Task Unknown_Property_Async()
        {
            // Arrange
            await CreateItemAsync(TypeOfTestDataEnum.Variant1);
            await CreateItemAsync(TypeOfTestDataEnum.Variant2);
            await CreateItemAsync(TypeOfTestDataEnum.NullValue);

            // Act
            var search = CrudStorage as ISearch <TestItemSort <TId>, TId>;

            Assert.IsNotNull(search, $"{CrudStorage.GetType().Name} was expected to implement {nameof(ISearch<TestItemSort<TId>, TId>)}");
            var page = await search.SearchAsync(new SearchDetails <TestItemSort <TId> >(new { UnknownProperty = "56" }), 0, 10);

            // Assert
            Assert.AreEqual(0, page.PageInfo.Returned);
        }
Beispiel #6
0
        public async Task FindUnique_NotFound_Async()
        {
            // Arrange
            await CreateItemAsync(TypeOfTestDataEnum.Variant2);
            await CreateItemAsync(TypeOfTestDataEnum.Variant2);
            await CreateItemAsync(TypeOfTestDataEnum.NullValue);

            // Act
            var search = CrudStorage as ISearch <TestItemSort <TId>, TId>;

            Assert.IsNotNull(search, $"{CrudStorage.GetType().Name} was expected to implement {nameof(ISearch<TestItemSort<TId>, TId>)}");
            const string variant       = "Variant1";
            var          searchDetails = new SearchDetails <TestItemSort <TId> >(new { Value = variant });

            var item = await search.FindUniqueAsync(searchDetails);

            // Assert
            Assert.IsNull(item);
        }
Beispiel #7
0
        public async Task Search_Item_Async(string value)
        {
            // Arrange
            await CreateItemAsync(TypeOfTestDataEnum.Variant1);
            await CreateItemAsync(TypeOfTestDataEnum.Variant2);
            await CreateItemAsync(TypeOfTestDataEnum.NullValue);

            // Act
            var search = CrudStorage as ISearch <TestItemSort <TId>, TId>;

            Assert.IsNotNull(search, $"{CrudStorage.GetType().Name} was expected to implement {nameof(ISearch<TestItemSort<TId>, TId>)}");
            var page = await search.SearchAsync(new SearchDetails <TestItemSort <TId> >(new { Value = value }), 0, 10);

            // Assert
            Assert.AreEqual(1, page.PageInfo.Returned);
            foreach (var item in page.Data)
            {
                Assert.AreEqual(value, item.Value);
            }
        }
        protected async Task PrepareStorageAsync(Guid id, TModel storageValue)
        {
            if (storageValue == null)
            {
                await CrudStorage.DeleteAsync(id);
            }
            else
            {
                var value = await CrudStorage.ReadAsync(id);

                if (value == null)
                {
                    await CrudStorage.CreateWithSpecifiedIdAsync(id, storageValue);
                }
                else if (!Equals(value, storageValue))
                {
                    await CrudStorage.UpdateAsync(id, storageValue);
                }
            }
        }
        protected async Task VerifyStorage(Guid id, TModel expectedStorageValue)
        {
            var actualStorageValue = await CrudStorage.ReadAsync(id);

            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(expectedStorageValue, actualStorageValue, "Storage verification failed.");
        }