< Summary

Class:Tests.CursorControllerTests
Assembly:CursorControllerTests
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/Tests/CursorControllerTests/CursorControllerTests.cs
Covered lines:88
Uncovered lines:1
Coverable lines:89
Total lines:288
Line coverage:98.8% (88 of 89)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SetUp()0%330100%
OnPointerHoverFeedbackIsDisplayedCorrectly()0%660100%
OnPointerHoverFeedbackNotDisplayedOnInvisibles()0%660100%
FeedbackIsNotDisplayedOnParent()0%660100%
OnPointerHoverFeedbackIsBlockedByUI()0%880100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/Tests/CursorControllerTests/CursorControllerTests.cs

#LineLine coverage
 1using DCL.Components;
 2using DCL.Helpers;
 3using DCL.Models;
 4using DCL;
 5using Newtonsoft.Json;
 6using NUnit.Framework;
 7using System.Collections;
 8using DCL.Camera;
 9using UnityEngine;
 10using UnityEngine.TestTools;
 11
 12namespace Tests
 13{
 14    public class CursorControllerTests : IntegrationTestSuite_Legacy
 15    {
 016        protected override bool enableSceneIntegrityChecker => false;
 17
 18        protected override IEnumerator SetUp()
 19        {
 420            yield return base.SetUp();
 421            Environment.i.world.sceneController.SortScenesByDistance();
 422            sceneInitialized = false;
 423        }
 24
 25        [UnityTest]
 26        public IEnumerator OnPointerHoverFeedbackIsDisplayedCorrectly()
 27        {
 28            IDCLEntity entity;
 29            BoxShape shape;
 30
 131            shape = TestHelpers.InstantiateEntityWithShape<BoxShape, BoxShape.Model>(
 32                scene,
 33                DCL.Models.CLASS_ID.BOX_SHAPE,
 34                Vector3.zero,
 35                out entity,
 36                new BoxShape.Model() { });
 37
 138            TestHelpers.SetEntityTransform(scene, entity, new Vector3(8, 2, 10), Quaternion.identity, new Vector3(3, 3, 
 139            yield return shape.routine;
 40
 141            var OnPointerDownModel = new OnPointerDown.Model()
 42            {
 43                type = OnPointerDown.NAME,
 44                uuid = "pointerevent-1"
 45            };
 46
 147            var component = TestHelpers.EntityComponentCreate<OnPointerDown, OnPointerDown.Model>(scene, entity,
 48                OnPointerDownModel, CLASS_ID_COMPONENT.UUID_CALLBACK);
 49
 150            Assert.IsTrue(component != null);
 51
 152            yield return null;
 53
 154            var cursorController = GameObject.FindObjectOfType<CursorController>();
 55
 56            // Check cursor shows normal sprite
 157            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.normalCursor);
 58
 159            DCLCharacterController.i.PauseGravity();
 160            DCLCharacterController.i.SetPosition(new Vector3(8, 1, 7f));
 61
 162            var cameraController = GameObject.FindObjectOfType<CameraController>();
 63
 64            // Rotate camera towards the interactive object
 165            var cameraRotationPayload = new CameraController.SetRotationPayload()
 66            {
 67                x = 45,
 68                y = 0,
 69                z = 0
 70            };
 71
 172            cameraController.SetRotation(JsonConvert.SerializeObject(cameraRotationPayload, Formatting.None, new JsonSer
 73            {
 74                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
 75            }));
 76
 177            yield return null;
 78
 79            // Check cursor shows hover sprite
 180            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.hoverCursor);
 81
 82            // Rotate the camera away from the interactive object
 183            cameraRotationPayload = new CameraController.SetRotationPayload()
 84            {
 85                x = 0,
 86                y = 0,
 87                z = 0,
 88                cameraTarget = (DCLCharacterController.i.transform.position - entity.gameObject.transform.position)
 89            };
 90
 191            cameraController.SetRotation(JsonConvert.SerializeObject(cameraRotationPayload, Formatting.None, new JsonSer
 92            {
 93                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
 94            }));
 95
 196            yield return null;
 97
 98            // Check cursor shows normal sprite
 199            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.normalCursor);
 100
 1101            DCLCharacterController.i.ResumeGravity();
 1102        }
 103
 104        [UnityTest]
 105        public IEnumerator OnPointerHoverFeedbackNotDisplayedOnInvisibles()
 106        {
 107            IDCLEntity entity;
 108            BoxShape shape;
 109
 1110            shape = TestHelpers.InstantiateEntityWithShape<BoxShape, BoxShape.Model>(
 111                scene,
 112                DCL.Models.CLASS_ID.BOX_SHAPE,
 113                Vector3.zero,
 114                out entity,
 115                new BoxShape.Model() { });
 116
 1117            TestHelpers.SetEntityTransform(scene, entity, new Vector3(8, 2, 10), Quaternion.identity, new Vector3(3, 3, 
 1118            yield return shape.routine;
 119
 1120            var OnPointerDownModel = new OnPointerDown.Model()
 121            {
 122                type = OnPointerDown.NAME,
 123                uuid = "pointerevent-1"
 124            };
 125
 1126            var component = TestHelpers.EntityComponentCreate<OnPointerDown, OnPointerDown.Model>(scene, entity,
 127                OnPointerDownModel, CLASS_ID_COMPONENT.UUID_CALLBACK);
 128
 1129            Assert.IsTrue(component != null);
 130
 1131            yield return null;
 132
 1133            var cursorController = GameObject.FindObjectOfType<CursorController>();
 134
 135            // Check cursor shows normal sprite
 1136            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.normalCursor);
 137
 1138            DCLCharacterController.i.PauseGravity();
 1139            DCLCharacterController.i.SetPosition(new Vector3(8, 1, 7f));
 140
 141            // Rotate camera towards the interactive object
 1142            cameraController.SetRotation(45, 0, 0);
 143
 1144            yield return null;
 145
 146            // Check cursor shows hover sprite
 1147            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.hoverCursor);
 148
 149            // Make shape invisible
 1150            TestHelpers.UpdateShape(scene, shape.id, JsonConvert.SerializeObject(
 151                new
 152                {
 153                    visible = false,
 154                    withCollisions = false,
 155                    isPointerBlocker = false
 156                }));
 157
 1158            yield return null;
 159
 160            // Check cursor shows normal sprite
 1161            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.normalCursor);
 162
 1163            DCLCharacterController.i.ResumeGravity();
 1164        }
 165
 166        [UnityTest]
 167        public IEnumerator FeedbackIsNotDisplayedOnParent()
 168        {
 1169            var cursorController = GameObject.FindObjectOfType<CursorController>();
 170
 1171            Assert.IsNotNull(cameraController, "camera is null?");
 172
 173            // Create parent entity
 174            IDCLEntity blockingEntity;
 1175            BoxShape blockingShape = TestHelpers.InstantiateEntityWithShape<BoxShape, BoxShape.Model>(
 176                scene,
 177                DCL.Models.CLASS_ID.BOX_SHAPE,
 178                Vector3.zero,
 179                out blockingEntity,
 180                new BoxShape.Model() { });
 1181            TestHelpers.SetEntityTransform(scene, blockingEntity, new Vector3(3, 3, 3), Quaternion.identity, new Vector3
 1182            yield return blockingShape.routine;
 183
 184            // Create target entity for click
 185            IDCLEntity clickTargetEntity;
 1186            BoxShape clickTargetShape = TestHelpers.InstantiateEntityWithShape<BoxShape, BoxShape.Model>(
 187                scene,
 188                DCL.Models.CLASS_ID.BOX_SHAPE,
 189                Vector3.zero,
 190                out clickTargetEntity,
 191                new BoxShape.Model() { });
 1192            TestHelpers.SetEntityTransform(scene, clickTargetEntity, new Vector3(0, 0, 5), Quaternion.identity, new Vect
 1193            yield return clickTargetShape.routine;
 194
 195            // Enparent target entity as a child of the blocking entity
 1196            TestHelpers.SetEntityParent(scene, clickTargetEntity, blockingEntity);
 197
 198            // Set character position and camera rotation
 1199            DCLCharacterController.i.SetPosition(new Vector3(3, 2, 1));
 1200            yield return null;
 201
 202            // Create pointer down component and add it to target entity
 1203            string onPointerId = "pointerevent-1";
 1204            var OnPointerDownModel = new OnPointerDown.Model()
 205            {
 206                type = OnPointerDown.NAME,
 207                uuid = onPointerId
 208            };
 1209            var component = TestHelpers.EntityComponentCreate<OnPointerDown, OnPointerDown.Model>(scene, clickTargetEnti
 210                OnPointerDownModel, CLASS_ID_COMPONENT.UUID_CALLBACK);
 211
 1212            Assert.IsTrue(component != null);
 213
 214            // Check if target entity is triggered by looking at the parent entity
 1215            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.normalCursor);
 216
 217            // Move character in front of target entity and rotate camera
 1218            DCLCharacterController.i.SetPosition(new Vector3(3, 2, 12));
 1219            cameraController.SetRotation(0, 0, 0, new Vector3(0, 0, -1));
 220
 1221            yield return null;
 222
 223            // Check if target entity is triggered when looked at directly
 1224            Assert.AreEqual(cursorController.cursorImage.sprite, cursorController.hoverCursor);
 1225        }
 226
 227        [UnityTest]
 228        public IEnumerator OnPointerHoverFeedbackIsBlockedByUI()
 229        {
 230            IDCLEntity entity;
 231            BoxShape shape;
 232
 1233            shape = TestHelpers.InstantiateEntityWithShape<BoxShape, BoxShape.Model>(
 234                scene,
 235                DCL.Models.CLASS_ID.BOX_SHAPE,
 236                Vector3.zero,
 237                out entity,
 238                new BoxShape.Model() { });
 239
 1240            TestHelpers.SetEntityTransform(scene, entity, new Vector3(8, 2, 10), Quaternion.identity, new Vector3(3, 3, 
 1241            yield return shape.routine;
 242
 1243            var onPointerDownModel = new OnPointerDown.Model()
 244            {
 245                type = OnPointerDown.NAME,
 246                uuid = "pointerevent-1"
 247            };
 1248            var component = TestHelpers.EntityComponentCreate<OnPointerDown, OnPointerDown.Model>(scene, entity,
 249                onPointerDownModel, CLASS_ID_COMPONENT.UUID_CALLBACK);
 1250            Assert.IsTrue(component != null);
 251
 1252            yield return null;
 253
 1254            DCLCharacterController.i.SetPosition(new Vector3(8, 1, 7f));
 255
 1256            var cameraController = GameObject.FindObjectOfType<CameraController>();
 257
 258            // Rotate camera towards the interactive object
 1259            cameraController.SetRotation(45, 0, 0);
 260
 1261            yield return null;
 262
 1263            var hoverCanvasController = InteractionHoverCanvasController.i;
 1264            Assert.IsNotNull(hoverCanvasController);
 265
 266            // Check hover feedback is enabled
 1267            Assert.IsTrue(hoverCanvasController.canvas.enabled);
 268
 269            // Put UI in the middle
 1270            UIScreenSpace screenSpaceShape =
 271                TestHelpers.SharedComponentCreate<UIScreenSpace, UIScreenSpace.Model>(scene,
 272                    CLASS_ID.UI_SCREEN_SPACE_SHAPE);
 1273            yield return screenSpaceShape.routine;
 274
 1275            UIContainerRect uiContainerRectShape =
 276                TestHelpers.SharedComponentCreate<UIContainerRect, UIContainerRect.Model>(scene,
 277                    CLASS_ID.UI_CONTAINER_RECT);
 1278            yield return uiContainerRectShape.routine;
 279
 1280            yield return null;
 281
 282            // Check hover feedback is no longer enabled
 1283            Assert.IsFalse(hoverCanvasController.canvas.enabled);
 284
 1285            DCLCharacterController.i.ResumeGravity();
 1286        }
 287    }
 288}
Generated by: ReportGenerator 4.8.9.0
07/13/2021 - 19:40:15
GitHub | www.palmmedia.de

Methods/Properties

enableSceneIntegrityChecker()
SetUp()
OnPointerHoverFeedbackIsDisplayedCorrectly()
OnPointerHoverFeedbackNotDisplayedOnInvisibles()
FeedbackIsNotDisplayedOnParent()
OnPointerHoverFeedbackIsBlockedByUI()