FruityFoundation/Base.Tests/Structures/DataReaderAsyncMaybeExtensionTests.cs

556 lines
16 KiB
C#

using System;
using System.Collections;
using System.Data.Common;
using System.Threading;
using System.Threading.Tasks;
using FruityFoundation.Base.Structures;
using NUnit.Framework;
namespace Base.Tests.Structures;
public class DataReaderAsyncMaybeExtensionTests
{
[Test]
public async Task DbDataReader_TryGetBooleanAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetBooleanAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<bool>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetBooleanAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithBoolean(true);
// Act
var result = await fakeDataReader.TryGetBooleanAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<bool>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(true));
}
[Test]
public async Task DbDataReader_TryGetByteAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetByteAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<byte>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetByteAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithByte(25);
// Act
var result = await fakeDataReader.TryGetByteAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<byte>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo((byte)25));
}
[Test]
public async Task DbDataReader_TryGetBytesAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetBytesAsync(0, 0, null, 0, 0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<long>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetBytesAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithBytes(25);
// Act
var result = await fakeDataReader.TryGetBytesAsync(0, 0, [], 0, 0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<long>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(25));
}
[Test]
public async Task DbDataReader_TryGetCharAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetCharAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<char>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetCharAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithChar('b');
// Act
var result = await fakeDataReader.TryGetCharAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<char>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo('b'));
}
[Test]
public async Task DbDataReader_TryGetCharsAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetCharsAsync(0, 0, null, 0, 0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<long>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetCharsAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithChars(25);
// Act
var result = await fakeDataReader.TryGetCharsAsync(0, 0, [], 0, 0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<long>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(25));
}
[Test]
public async Task DbDataReader_TryGetDateTimeAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetDateTimeAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<DateTime>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetDateTimeAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithDateTime(new DateTime(2024, 05, 03, 17, 21, 0, DateTimeKind.Utc));
// Act
var result = await fakeDataReader.TryGetDateTimeAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<DateTime>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(new DateTime(2024, 05, 03, 17, 21, 0, DateTimeKind.Utc)));
}
[Test]
public async Task DbDataReader_TryGetDecimalAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetDecimalAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<decimal>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetDecimalAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithDecimal(25.0m);
// Act
var result = await fakeDataReader.TryGetDecimalAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<decimal>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(25.0m));
}
[Test]
public async Task DbDataReader_TryGetFloatAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetFloatAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<float>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetFloatAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithFloat(25.0f);
// Act
var result = await fakeDataReader.TryGetFloatAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<float>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(25.0f));
}
[Test]
public async Task DbDataReader_TryGetGuidAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetGuidAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<Guid>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetGuidAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithGuid(new Guid("b3e7f4d3-3b7b-4b1b-8e0e-3b1b7b4b3e7f"));
// Act
var result = await fakeDataReader.TryGetGuidAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<Guid>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(new Guid("b3e7f4d3-3b7b-4b1b-8e0e-3b1b7b4b3e7f")));
}
[Test]
public async Task DbDataReader_TryGetInt16Async_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetInt16Async(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<short>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetInt16Async_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithInt16(25);
// Act
var result = await fakeDataReader.TryGetInt16Async(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<short>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo((short)25));
}
[Test]
public async Task DbDataReader_TryGetInt32Async_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetInt32Async(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<int>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetInt32Async_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithInt32(25);
// Act
var result = await fakeDataReader.TryGetInt32Async(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<int>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(25));
}
[Test]
public async Task DbDataReader_TryGetInt64Async_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetInt64Async(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<long>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetInt64Async_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithInt64(25L);
// Act
var result = await fakeDataReader.TryGetInt64Async(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<long>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo(25));
}
[Test]
public async Task DbDataReader_TryGetStringAsync_WithDbNull_ReturnsEmptyMaybe()
{
// Arrange
var fakeDataReader = MockDbDataReader.Empty;
// Act
var result = await fakeDataReader.TryGetStringAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<string>>());
Assert.That(result.HasValue, Is.False);
}
[Test]
public async Task DbDataReader_TryGetStringAsync_WithValue_ReturnsMaybeWithValue()
{
// Arrange
var fakeDataReader = MockDbDataReader.WithString("banana");
// Act
var result = await fakeDataReader.TryGetStringAsync(0);
// Assert
Assert.That(result, Is.InstanceOf<Maybe<string>>());
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.EqualTo("banana"));
}
private class MockDbDataReader : DbDataReader
{
private readonly bool _isNull;
private readonly Maybe<bool> _boolValue;
private readonly Maybe<byte> _byteValue;
private readonly Maybe<long> _bytesValue;
private readonly Maybe<char> _charValue;
private readonly Maybe<long> _charsValue;
private readonly Maybe<DateTime> _dateTimeValue;
private readonly Maybe<decimal> _decimalValue;
private readonly Maybe<float> _floatValue;
private readonly Maybe<Guid> _guidValue;
private readonly Maybe<short> _int16Value;
private readonly Maybe<int> _int32Value;
private readonly Maybe<long> _int64Value;
private readonly Maybe<string> _stringValue;
private MockDbDataReader(
bool isNull,
Maybe<bool> boolValue = default,
Maybe<byte> byteValue = default,
Maybe<long> bytesValue = default,
Maybe<char> charValue = default,
Maybe<long> charsValue = default,
Maybe<DateTime> dateTimeValue = default,
Maybe<decimal> decimalValue = default,
Maybe<float> floatValue = default,
Maybe<Guid> guidValue = default,
Maybe<short> int16Value = default,
Maybe<int> int32Value = default,
Maybe<long> int64Value = default,
Maybe<string> stringValue = default
)
{
_isNull = isNull;
_boolValue = boolValue;
_byteValue = byteValue;
_bytesValue = bytesValue;
_charValue = charValue;
_charsValue = charsValue;
_dateTimeValue = dateTimeValue;
_decimalValue = decimalValue;
_floatValue = floatValue;
_guidValue = guidValue;
_int16Value = int16Value;
_int32Value = int32Value;
_int64Value = int64Value;
_stringValue = stringValue;
//
}
public static MockDbDataReader Empty => new(isNull: true);
public static MockDbDataReader WithBoolean(bool value) => new(isNull: false, boolValue: Maybe.Create(value));
public static MockDbDataReader WithByte(byte value) => new(isNull: false, byteValue: Maybe.Create(value));
public static MockDbDataReader WithBytes(long value) => new(isNull: false, bytesValue: Maybe.Create(value));
public static MockDbDataReader WithChar(char value) => new(isNull: false, charValue: Maybe.Create(value));
public static MockDbDataReader WithChars(long value) => new(isNull: false, charsValue: Maybe.Create(value));
public static MockDbDataReader WithDateTime(DateTime value) => new(isNull: false, dateTimeValue: Maybe.Create(value));
public static MockDbDataReader WithDecimal(decimal value) => new(isNull: false, decimalValue: Maybe.Create(value));
public static MockDbDataReader WithFloat(float value) => new(isNull: false, floatValue: Maybe.Create(value));
public static MockDbDataReader WithGuid(Guid value) => new(isNull: false, guidValue: Maybe.Create(value));
public static MockDbDataReader WithInt16(short value) => new(isNull: false, int16Value: Maybe.Create(value));
public static MockDbDataReader WithInt32(int value) => new(isNull: false, int32Value: Maybe.Create(value));
public static MockDbDataReader WithInt64(long value) => new(isNull: false, int64Value: Maybe.Create(value));
public static MockDbDataReader WithString(string value) => new(isNull: false, stringValue: Maybe.Create(value));
/// <inheritdoc />
public override bool GetBoolean(int ordinal) => _boolValue.Value;
/// <inheritdoc />
public override byte GetByte(int ordinal) => _byteValue.Value;
/// <inheritdoc />
public override long GetBytes(int ordinal, long dataOffset, byte[]? buffer, int bufferOffset, int length) =>
_bytesValue.Value;
/// <inheritdoc />
public override char GetChar(int ordinal) => _charValue.Value;
/// <inheritdoc />
public override long GetChars(int ordinal, long dataOffset, char[]? buffer, int bufferOffset, int length) =>
_charsValue.Value;
/// <inheritdoc />
public override string GetDataTypeName(int ordinal) => throw new NotImplementedException();
/// <inheritdoc />
public override DateTime GetDateTime(int ordinal) => _dateTimeValue.Value;
/// <inheritdoc />
public override decimal GetDecimal(int ordinal) => _decimalValue.Value;
/// <inheritdoc />
public override double GetDouble(int ordinal) => throw new NotImplementedException();
/// <inheritdoc />
public override Type GetFieldType(int ordinal) => throw new NotImplementedException();
/// <inheritdoc />
public override float GetFloat(int ordinal) => _floatValue.Value;
/// <inheritdoc />
public override Guid GetGuid(int ordinal) => _guidValue.Value;
/// <inheritdoc />
public override short GetInt16(int ordinal) => _int16Value.Value;
/// <inheritdoc />
public override int GetInt32(int ordinal) => _int32Value.Value;
/// <inheritdoc />
public override long GetInt64(int ordinal) => _int64Value.Value;
/// <inheritdoc />
public override string GetName(int ordinal) => throw new NotImplementedException();
/// <inheritdoc />
public override int GetOrdinal(string name) => throw new NotImplementedException();
/// <inheritdoc />
public override string GetString(int ordinal) => _stringValue.Value;
/// <inheritdoc />
public override object GetValue(int ordinal) => throw new NotImplementedException();
/// <inheritdoc />
public override int GetValues(object[] values) => throw new NotImplementedException();
/// <inheritdoc />
public override bool IsDBNull(int ordinal) => throw new NotImplementedException();
/// <inheritdoc />
public override Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellationToken) =>
Task.FromResult(_isNull);
/// <inheritdoc />
public override int FieldCount => throw new NotImplementedException();
/// <inheritdoc />
public override object this[int ordinal] => throw new NotImplementedException();
/// <inheritdoc />
public override object this[string name] => throw new NotImplementedException();
/// <inheritdoc />
public override int RecordsAffected => throw new NotImplementedException();
/// <inheritdoc />
public override bool HasRows => throw new NotImplementedException();
/// <inheritdoc />
public override bool IsClosed => throw new NotImplementedException();
/// <inheritdoc />
public override bool NextResult() => throw new NotImplementedException();
/// <inheritdoc />
public override bool Read() => throw new NotImplementedException();
/// <inheritdoc />
public override int Depth => throw new NotImplementedException();
/// <inheritdoc />
public override IEnumerator GetEnumerator() => throw new NotImplementedException();
}
}