UguiDoubleClickOperatorTest.cs

// Copyright (c) 2023-2025 Koji Hasegawa.
// This software is released under the MIT License.

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;
using NUnit.Framework;
using TestHelper.Attributes;
using TestHelper.UI.TestDoubles;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using Object = UnityEngine.Object;

namespace TestHelper.UI.Operators
{
    [TestFixture]
    public class UguiDoubleClickOperatorTest
    {
        private readonly IOperator _sut = new UguiDoubleClickOperator();

        #region Constructor Tests

        [Test]
        public void Constructor_ValidDoubleClickInterval_ObjectCreatedSuccessfully()
        {
            var sut = new UguiDoubleClickOperator();

            Assert.That(sut, Is.Not.Null);
        }

        [Test]
        public void Constructor_ZeroDoubleClickInterval_ThrowsArgumentException()
        {
            Assert.That(() => new UguiDoubleClickOperator(0), Throws.ArgumentException);
        }

        [Test]
        public void Constructor_NegativeDoubleClickInterval_ThrowsArgumentException()
        {
            Assert.That(() => new UguiDoubleClickOperator(-1), Throws.ArgumentException);
        }

        [Test]
        public void Constructor_AllParametersSpecified_ObjectCreatedSuccessfully()
        {
            var logger = new SpyLogger();
            var screenshotOptions = new ScreenshotOptions();

            var sut = new UguiDoubleClickOperator(logger: logger, screenshotOptions: screenshotOptions);

            Assert.That(sut, Is.Not.Null);
        }

        [Test]
        public void Constructor_NullLogger_ObjectCreatedSuccessfully()
        {
            var sut = new UguiDoubleClickOperator();

            Assert.That(sut, Is.Not.Null);
        }

        #endregion

        #region CanOperate Tests

        [Test]
        public void CanOperate_NullGameObject_ReturnsFalse()
        {
            var actual = _sut.CanOperate(null);
            Assert.That(actual, Is.False);
        }

        [Test]
        [CreateScene]
        public void CanOperate_DestroyedGameObject_ReturnsFalse()
        {
            var gameObject = new GameObject(null, typeof(SpyOnPointerClickHandler));
            Object.DestroyImmediate(gameObject);

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        [Test]
        [CreateScene]
        public void CanOperate_InactiveGameObject_ReturnsFalse()
        {
            var gameObject = new GameObject(null, typeof(SpyOnPointerClickHandler));
            gameObject.SetActive(false);

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        [Test]
        [CreateScene]
        public void CanOperate_InactiveParentGameObject_ReturnsFalse()
        {
            var parent = new GameObject();
            var gameObject = new GameObject(null, typeof(SpyOnPointerClickHandler));
            gameObject.transform.SetParent(parent.transform);
            parent.SetActive(false);

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        [Test]
        [CreateScene]
        public void CanOperate_NoHandler_ReturnsFalse()
        {
            var gameObject = new GameObject();

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        [Test]
        [CreateScene]
        public void CanOperate_WithEventTriggerNotIncludePointerClick_ReturnsFalse()
        {
            var gameObject = new GameObject(null, typeof(EventTrigger));

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        [Test]
        [CreateScene]
        public void CanOperate_WithEventTriggerIncludePointerClick_ReturnsTrue()
        {
            var gameObject = new GameObject();
            var eventTrigger = gameObject.AddComponent<EventTrigger>();
            eventTrigger.triggers.Add(CreatePointerClickEntry());

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.True);
        }

        [Test]
        [CreateScene]
        public void CanOperate_WithDisabledEventTriggerIncludePointerClick_ReturnsFalse()
        {
            var gameObject = new GameObject();
            var eventTrigger = gameObject.AddComponent<EventTrigger>();
            eventTrigger.triggers.Add(CreatePointerClickEntry());
            eventTrigger.enabled = false;

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        private static EventTrigger.Entry CreatePointerClickEntry() =>
            new EventTrigger.Entry
            {
                eventID = EventTriggerType.PointerClick,
                callback = new EventTrigger.TriggerEvent()
            };

        [Test]
        [CreateScene]
        public void CanOperate_WithPointerClickHandler_ReturnsTrue()
        {
            var gameObject = new GameObject(null, typeof(SpyOnPointerClickHandler));

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.True);
        }

        [Test]
        [CreateScene]
        public void CanOperate_WithDisabledPointerClickHandler_ReturnsFalse()
        {
            var gameObject = new GameObject(null, typeof(SpyOnPointerClickHandler));
            var handler = gameObject.GetComponent<SpyOnPointerClickHandler>();
            handler.enabled = false;

            var actual = _sut.CanOperate(gameObject);
            Assert.That(actual, Is.False);
        }

        #endregion

        #region OperateAsync Tests

        [Test]
        [CreateScene]
        public async Task OperateAsync_ValidGameObject_DoubleClickOccurs()
        {
            var gameObject = new GameObject();
            var spy = gameObject.AddComponent<SpyOnPointerClickHandler>();

            var sut = new UguiDoubleClickOperator();
            Assume.That(sut.CanOperate(gameObject), Is.True);
            await sut.OperateAsync(gameObject);

            Assert.That(spy.ClickCount, Is.EqualTo(2));
        }

        [TestCase(1)]
        [TestCase(100)]
        [TestCase(200)]
        [TestCase(500)]
        [CreateScene]
        public async Task OperateAsync_VariousIntervals_ClicksWithCorrectTiming(int intervalMillis)
        {
            var gameObject = new GameObject();
            var spy = gameObject.AddComponent<SpyOnPointerClickHandler>();

            var stopwatch = Stopwatch.StartNew();
            var sut = new UguiDoubleClickOperator(intervalMillis);
            await sut.OperateAsync(gameObject);
            stopwatch.Stop();

            Assert.That(spy.ClickCount, Is.EqualTo(2));
            Assert.That(stopwatch.ElapsedMilliseconds, Is.GreaterThanOrEqualTo(intervalMillis));
        }

        [Test]
        [CreateScene]
        public async Task OperateAsync_PointerClickHandler_OnPointerClickCalled()
        {
            var gameObject = new GameObject();
            var spy = gameObject.AddComponent<SpyOnPointerClickHandler>();

            var sut = new UguiDoubleClickOperator();
            await sut.OperateAsync(gameObject);

            Assert.That(spy.WasClicked, Is.True);
        }

        [Test]
        [CreateScene]
        public async Task OperateAsync_DoubleClickSequenceAndTiming_CorrectInterval()
        {
            var gameObject = new GameObject();
            var spy = gameObject.AddComponent<SpyOnPointerClickHandler>();

            var sut = new UguiDoubleClickOperator(50);
            await sut.OperateAsync(gameObject);

            Assert.That(spy.ClickCount, Is.EqualTo(2));
            var interval = (spy.ClickTimestamps[1] - spy.ClickTimestamps[0]).TotalMilliseconds;
            Assert.That(interval, Is.GreaterThan(17).And.LessThan(200));
        }

        [Test]
        [CreateScene]
        public async Task OperateAsync_WithLogger_LoggingWorks()
        {
            var gameObject = new GameObject(null, typeof(Button));
            var spyLogger = new SpyLogger();

            var sut = new UguiDoubleClickOperator(logger: spyLogger);
            await sut.OperateAsync(gameObject);

            Assert.That(spyLogger.Messages, Is.Not.Empty);
        }

        [Test]
        [CreateScene]
        public async Task OperateAsync_WithScreenshotOptions_TakeScreenshotOnce()
        {
            var gameObject = new GameObject(null, typeof(Button));
            var directory = Application.temporaryCachePath;
            var filename = $"{TestContext.CurrentContext.Test.FullName}.png";
            var path = Path.Combine(directory, filename);
            if (File.Exists(path))
            {
                File.Delete(path);
            }

            var screenshotOptions = new ScreenshotOptions
            {
                Directory = directory,
                FilenameStrategy = new StubScreenshotFilenameStrategy(filename),
            };

            var sut = new UguiDoubleClickOperator(screenshotOptions: screenshotOptions);
            await sut.OperateAsync(gameObject);

            Assert.That(path, Does.Exist);
        }

        [Test]
        [CreateScene]
        public async Task OperateAsync_DestroyedGameObject_ThrowsException()
        {
            var gameObject = new GameObject(null, typeof(Button));
            Object.DestroyImmediate(gameObject);

            var sut = new UguiDoubleClickOperator();

            try
            {
                await sut.OperateAsync(gameObject);
                Assert.Fail("Expected exception for destroyed GameObject");
            }
            catch (Exception)
            {
                Assert.Pass("Exception thrown as expected for destroyed GameObject");
            }
        }

        #endregion
    }
}