public async Task WithContentAsync_WhenDataIsNonEmptyDomainObjectCollectionContainingNullValues_AssertConvertAsyncWasNotCalledOnDomainObjectToCsvConverter()
        {
            IExportDataContentBuilder sut = CreateSut();

            await sut.WithContentAsync(CreateExportQuery(), new object[] { null, null, null });

            _domainObjectToCsvConverterMock.Verify(m => m.ConvertAsync(It.IsAny <object>()), Times.Never);
        }
예제 #2
0
        public void WithContentAsync_WhenQueryIsNull_ThrowsArgumentNullException()
        {
            using IExportDataContentBuilder sut = CreateSut();

            ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.WithContentAsync <IExportQuery, object>(null, _fixture.Create <object>()));

            Assert.That(result.ParamName, Is.EqualTo("query"));
        }
        public void WithHeaderAsync_WhenQueryIsNull_ThrowsArgumentNullException()
        {
            IExportDataContentBuilder sut = CreateSut();

            ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.WithHeaderAsync <IExportQuery>(null));

            Assert.That(result.ParamName, Is.EqualTo("query"));
        }
        public void WithContentAsync_WhenQueryIsNull_ThrowsArgumentNullException()
        {
            IExportDataContentBuilder sut = CreateSut();

            ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.WithContentAsync <IExportQuery, IEnumerable <object> >(null, new object[0]));

            Assert.That(result.ParamName, Is.EqualTo("query"));
        }
예제 #5
0
        public void WithContentAsync_WhenDataIsNull_ThrowsArgumentNullException()
        {
            using IExportDataContentBuilder sut = CreateSut();

            ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.WithContentAsync <IExportQuery, object>(CreateExportQuery(), null));

            Assert.That(result.ParamName, Is.EqualTo("data"));
        }
예제 #6
0
        public async Task BuildAsync_WhenNoContentHasBeenWritten_ReturnsNotNull()
        {
            using IExportDataContentBuilder sut = CreateSut();

            byte[] result = await sut.BuildAsync();

            Assert.That(result, Is.Not.Null);
        }
예제 #7
0
        public async Task BuildAsync_WhenNoContentHasBeenWritten_ReturnsEmptyByteArray()
        {
            using IExportDataContentBuilder sut = CreateSut();

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.EqualTo(0));
        }
예제 #8
0
        public async Task BuildAsync_WhenNoContentHasBeenWritten_ReturnsByteArray()
        {
            using IExportDataContentBuilder sut = CreateSut();

            byte[] result = await sut.BuildAsync();

            Assert.That(result, Is.TypeOf <byte[]>());
        }
        public async Task WithHeaderAsync_WhenQueryIsNotNull_AssertGetColumnNamesAsyncWasCalledOnDomainObjectToCsvConverter()
        {
            IExportDataContentBuilder sut = CreateSut();

            await sut.WithHeaderAsync(CreateExportQuery());

            _domainObjectToCsvConverterMock.Verify(m => m.GetColumnNamesAsync(), Times.Once);
        }
        public void WithContentAsync_WhenDataCantBeCastToEnumerableOfDomainObject_ThrowsArgumentException()
        {
            IExportDataContentBuilder sut = CreateSut();

            ArgumentException result = Assert.ThrowsAsync <ArgumentException>(async() => await sut.WithContentAsync(CreateExportQuery(), _fixture.Create <object>()));

            Assert.That(result.Message, Is.EqualTo($"Value cannot be cast to IEnumerable<{nameof(Object)}>. (Parameter 'data')"));
            Assert.That(result.ParamName, Is.EqualTo("data"));
        }
        public async Task WithContentAsync_WhenDataIsNonEmptyDomainObjectCollectionContainingValues_AssertConvertAsyncWasCalledOnDomainObjectToCsvConverter()
        {
            IExportDataContentBuilder sut = CreateSut();

            object[] domainObjectCollection = _fixture.CreateMany <object>(_random.Next(5, 10)).ToArray();
            await sut.WithContentAsync(CreateExportQuery(), domainObjectCollection);

            _domainObjectToCsvConverterMock.Verify(m => m.ConvertAsync(It.IsNotNull <object>()), Times.Exactly(domainObjectCollection.Length));
        }
예제 #12
0
            public MyExportQueryHandler(bool hasExportData, string exportData, IExportDataContentBuilder exportDataContentBuilder)
            {
                Core.NullGuard.NotNull(exportData, nameof(exportData))
                .NotNull(exportDataContentBuilder, nameof(exportDataContentBuilder));

                _hasExportData            = hasExportData;
                _exportData               = exportData;
                _exportDataContentBuilder = exportDataContentBuilder;
            }
        public async Task WithContentAsync_WhenDataIsEmptyDomainObjectCollection_AssertNoWrittenData()
        {
            IExportDataContentBuilder sut = CreateSut();

            await sut.WithContentAsync(CreateExportQuery(), new object[0]);

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.EqualTo(0));
        }
예제 #14
0
        public void Dispose_WhenCalled_AssertWriterHasBeenDisposed()
        {
            using IExportDataContentBuilder sut = CreateSut();

            StreamWriter writer = ((MyExportDataContentBuilder)sut).GetWriter();

            sut.Dispose();

            Assert.ThrowsAsync <ObjectDisposedException>(async() => await writer.WriteAsync(_fixture.Create <string>()));
        }
        public async Task WithContentAsync_WhenConvertAsyncReturnsNullForOneDomainObject_AssertNoWrittenData()
        {
            IExportDataContentBuilder sut = CreateSut(false);

            await sut.WithContentAsync(CreateExportQuery(), new[] { _fixture.Create <object>() });

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.EqualTo(0));
        }
        public async Task WithContentAsync_WhenConvertAsyncReturnsEmptyCollectionForOneDomainObject_AssertNoWrittenData()
        {
            IExportDataContentBuilder sut = CreateSut(columnValueCollection: new string[0]);

            await sut.WithContentAsync(CreateExportQuery(), new[] { _fixture.Create <object>() });

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.EqualTo(0));
        }
        public async Task WithContentAsync_WhenConvertAsyncReturnsNonEmptyCollectionContainingWhiteSpaceValuesForOneDomainObject_AssertColumnValuesHasBeenWritten()
        {
            IExportDataContentBuilder sut = CreateSut(columnValueCollection: new[] { " ", "  ", "   " });

            await sut.WithContentAsync(CreateExportQuery(), new[] { _fixture.Create <object>() });

            byte[] result = await sut.BuildAsync();

            Assert.That(Encoding.UTF8.GetString(result), Is.EqualTo($"\"\";\"\";\"\"{Environment.NewLine}"));
        }
예제 #18
0
        public async Task BuildAsync_WhenContentHasBeenWritten_ReturnsNonEmptyByteArray()
        {
            using IExportDataContentBuilder sut = CreateSut();

            await sut.WithContentAsync(CreateExportQuery(), _fixture.Create <string>());

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.GreaterThan(0));
        }
예제 #19
0
        public async Task BuildAsync_WhenContentHasBeenWritten_ReturnsNotNull()
        {
            using IExportDataContentBuilder sut = CreateSut();

            await sut.WithContentAsync(CreateExportQuery(), _fixture.Create <string>());

            byte[] result = await sut.BuildAsync();

            Assert.That(result, Is.Not.Null);
        }
        public async Task WithHeaderAsync_WhenGetColumnNamesAsyncReturnsNonEmptyCollectionContainingEmptyValues_AssertNoWrittenData()
        {
            IExportDataContentBuilder sut = CreateSut(columnNameCollection: new[] { string.Empty, string.Empty, string.Empty });

            await sut.WithHeaderAsync(CreateExportQuery());

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.EqualTo(0));
        }
        public async Task WithHeaderAsync_WhenGetColumnNamesAsyncReturnsNull_AssertNoWrittenData()
        {
            IExportDataContentBuilder sut = CreateSut(false);

            await sut.WithHeaderAsync(CreateExportQuery());

            byte[] result = await sut.BuildAsync();

            Assert.That(result.Length, Is.EqualTo(0));
        }
        public async Task WithContentAsync_WhenDataIsNonEmptyDomainObjectCollectionContainingValues_AssertDataForDomainObjectCollectionHasBeenWritten()
        {
            IExportDataContentBuilder sut = CreateSut();

            object[] domainObjectCollection = _fixture.CreateMany <object>(_random.Next(5, 10)).ToArray();
            await sut.WithContentAsync(CreateExportQuery(), domainObjectCollection);

            byte[] result = await sut.BuildAsync();

            Assert.That(new Regex(Environment.NewLine, RegexOptions.Compiled).Matches(Encoding.UTF8.GetString(result)).Count, Is.EqualTo(domainObjectCollection.Length));
        }
예제 #23
0
        public async Task BuildAsync_WhenContentHasBeenWritten_ReturnsUTF8ByteArrayForContent()
        {
            using IExportDataContentBuilder sut = CreateSut();

            string content = _fixture.Create <string>();
            await sut.WithContentAsync(CreateExportQuery(), content);

            byte[] result = await sut.BuildAsync();

            Assert.That(Encoding.UTF8.GetString(result), Is.EqualTo(content));
        }
        public async Task WithHeaderAsync_WhenGetColumnNamesAsyncReturnsNonEmptyCollectionContainingValues_AssertColumnNamesHasBeenWritten()
        {
            string[] columnNameCollection = _fixture.CreateMany <string>(_random.Next(5, 10)).ToArray();
            IExportDataContentBuilder sut = CreateSut(columnNameCollection: columnNameCollection);

            await sut.WithHeaderAsync(CreateExportQuery());

            byte[] result = await sut.BuildAsync();

            Assert.That(Encoding.UTF8.GetString(result), Is.EqualTo(string.Join(';', columnNameCollection.Select(columnName => $"\"{columnName}\"")) + Environment.NewLine));
        }
예제 #25
0
        public void Dispose_WhenCalledMultipleTimes_ThrowsNoException()
        {
            using IExportDataContentBuilder sut = CreateSut();

            int numberOfTimes = _random.Next(5, 10);

            while (numberOfTimes > 0)
            {
                sut.Dispose();
                numberOfTimes--;
            }
        }
        public async Task WithContentAsync_WhenDataIsNonEmptyDomainObjectCollectionContainingValues_AssertConvertAsyncWasCalledOnDomainObjectToCsvConverterForEachDomainObject()
        {
            IExportDataContentBuilder sut = CreateSut();

            object[] domainObjectCollection = _fixture.CreateMany <object>(_random.Next(5, 10)).ToArray();
            await sut.WithContentAsync(CreateExportQuery(), domainObjectCollection);

            foreach (object domainObject in domainObjectCollection)
            {
                _domainObjectToCsvConverterMock.Verify(m => m.ConvertAsync(It.Is <object>(value => value != null && value == domainObject)), Times.Once);
            }
        }
        public async Task <byte[]> QueryAsync(TExportQuery query)
        {
            NullGuard.NotNull(query, nameof(query));

            TExportData exportData = await GetExportDataAsync(query);

            if (exportData == null)
            {
                return(new byte[0]);
            }

            using IExportDataContentBuilder exportDataContentBuilder = await CreateExportDataContentBuilderAsync();

            await exportDataContentBuilder.WithHeaderAsync(query);

            await exportDataContentBuilder.WithContentAsync(query, exportData);

            await exportDataContentBuilder.WithFooterAsync(query);

            return(await exportDataContentBuilder.BuildAsync());
        }
예제 #28
0
        public async Task WithContentAsync_WhenQueryAndDataIsNotNull_ThrowsNoException()
        {
            using IExportDataContentBuilder sut = CreateSut();

            await sut.WithContentAsync(CreateExportQuery(), _fixture.Create <object>());
        }
        public async Task WithHeaderAsync_WhenQueryIsNotNull_ThrowsNoException()
        {
            using IExportDataContentBuilder sut = CreateSut();

            await sut.WithHeaderAsync(CreateExportQuery());
        }