request/src/request.result.tests/ResultEqualityTests.cs

// Copyright (c) The Geekeey Authors
// SPDX-License-Identifier: EUPL-1.2

namespace Geekeey.Request.Result.Tests;

internal sealed class ResultEqualityTests
{
	[Test]
	public async Task I_can_equal_t_and_get_true_for_success_with_equal_value()
	{
		var a = Prelude.Success(2);
		var b = 2;

		await Assert.That(a.Equals(b)).IsTrue();
	}

	[Test]
	public async Task I_can_equal_t_and_get_false_for_success_with_unequal_value()
	{
		var a = Prelude.Success(2);
		var b = 3;

		await Assert.That(a.Equals(b)).IsFalse();
	}

	[Test]
	public async Task I_can_equal_t_and_get_false_for_failure()
	{
		var a = Prelude.Failure<int>("error");
		var b = 2;

		await Assert.That(a.Equals(b)).IsFalse();
	}

	[Test]
	public async Task I_can_equal_result_and_get_true_for_success_and_success_with_equal_value()
	{
		var a = Prelude.Success(2);
		var b = Prelude.Success(2);

		await Assert.That(a.Equals(b)).IsTrue();
	}

	[Test]
	public async Task I_can_equal_result_and_get_false_for_success_and_success_with_unequal_value()
	{
		var a = Prelude.Success(2);
		var b = Prelude.Success(3);

		await Assert.That(a.Equals(b)).IsFalse();
	}

	[Test]
	public async Task I_can_equals_result_and_get_false_for_success_and_failure()
	{
		var a = Prelude.Success(2);
		var b = Prelude.Failure<int>("error 1");

		await Assert.That(a.Equals(b)).IsFalse();
	}

	[Test]
	public async Task I_can_equals_result_and_get_false_for_failure_and_success()
	{
		var a = Prelude.Failure<int>("error");
		var b = Prelude.Success(2);

		await Assert.That(a.Equals(b)).IsFalse();
	}

	[Test]
	public async Task I_can_equals_result_and_get_true_for_failure_and_failure()
	{
		var a = Prelude.Failure<int>("error 1");
		var b = Prelude.Failure<int>("error 2");

		await Assert.That(a.Equals(b)).IsTrue();
	}

	[Test]
	public async Task I_can_equal_t_and_get_true_for_success_with_equal_value_using_comparer()
	{
		var a = Prelude.Success(2);
		var b = 2;

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsTrue();
	}

	[Test]
	public async Task I_can_equal_t_and_get_false_for_success_with_unequal_value_using_comparer()
	{
		var a = Prelude.Success(2);
		var b = 3;

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsFalse();
	}

	[Test]
	public async Task I_can_equal_t_and_get_false_for_failure_using_comparer()
	{
		var a = Prelude.Failure<int>("error");
		var b = 2;

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsFalse();
	}

	[Test]
	public async Task I_can_equal_result_and_get_true_for_success_and_success_with_equal_value_using_comparer()
	{
		var a = Prelude.Success(2);
		var b = Prelude.Success(2);

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsTrue();
	}

	[Test]
	public async Task I_can_equal_result_and_get_false_for_success_and_success_with_unequal_value_using_comparer()
	{
		var a = Prelude.Success(2);
		var b = Prelude.Success(3);

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsFalse();
	}

	[Test]
	public async Task I_can_equals_result_and_get_false_for_success_and_failure_using_comparer()
	{
		var a = Prelude.Success(2);
		var b = Prelude.Failure<int>("error 1");

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsFalse();
	}

	[Test]
	public async Task I_can_equals_result_and_get_false_for_failure_and_success_using_comparer()
	{
		var a = Prelude.Failure<int>("error");
		var b = Prelude.Success(2);

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsFalse();
	}

	[Test]
	public async Task I_can_equals_result_and_get_true_for_failure_and_failure_using_comparer()
	{
		var a = Prelude.Failure<int>("error 1");
		var b = Prelude.Failure<int>("error 2");

		await Assert.That(a.Equals(b, EqualityComparer<int>.Default)).IsTrue();
	}

	[Test]
	public async Task I_can_get_hashcode_and_get_hashcode_for_success()
	{
		var result = Prelude.Success(2);

		await Assert.That(result.GetHashCode()).IsEqualTo(2.GetHashCode());
	}

	[Test]
	public async Task I_can_get_hashcode_and_get_zero_for_null()
	{
		var result = Prelude.Success<string?>(null);

		await Assert.That(result.GetHashCode()).IsZero();
	}

	[Test]
	public async Task I_can_get_hashcode_and_get_zero_for_failure()
	{
		var result = Prelude.Failure<int>("error");

		await Assert.That(result.GetHashCode()).IsZero();
	}
}