< Summary

Class:AvatarEditorHUD_Tests.AvatarEditorHUDControllerShould
Assembly:AvatarEditorHUDTests
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/HUD/AvatarEditorHUD/Tests/AvatarEditorHUDControllerShould.cs
Covered lines:86
Uncovered lines:0
Coverable lines:86
Total lines:304
Line coverage:100% (86 of 86)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SetUp()0%440100%
TearDown()0%330100%
AutofillMandatoryCategoriesIfNotProvided()0%440100%
ReplaceNotSupportedWearablesWhenChangingBodyShape()0%220100%
LoadUserProfileByConstructor()0%110100%
ReactToUserProfileUpdate()0%110100%
ProcessClickedBodyShape()0%110100%
ProcessClickedWearables()0%110100%
ProcessSupportedClickedHairColor()0%110100%
ProcessNotSupportedClickedHairColor()0%110100%
ProcessSupportedClickedSkinColor()0%110100%
ProcessNotSupportedClickedSkinColor()0%110100%
ProcessSupportedClickedEyeColor()0%110100%
ProcessNotSupportedClickedEyesColor()0%110100%
RandomizeOnlyTheSelectedSetOfWearables()0%330100%
SaveAvatarProperly()0%110100%
AssertAvatarModelAgainstAvatarEditorHUDModel(...)0%220100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/HUD/AvatarEditorHUD/Tests/AvatarEditorHUDControllerShould.cs

#LineLine coverage
 1using AvatarShape_Tests;
 2using DCL;
 3using NUnit.Framework;
 4using System.Collections;
 5using System.Collections.Generic;
 6using System.Linq;
 7using UnityEngine;
 8using UnityEngine.TestTools;
 9
 10namespace AvatarEditorHUD_Tests
 11{
 12    public class AvatarEditorHUDControllerShould : IntegrationTestSuite_Legacy
 13    {
 14        private const string EYEBROWS_ID = "urn:decentraland:off-chain:base-avatars:f_eyebrows_01";
 15        private const string FEMALE_CATGLASSES_ID = "urn:decentraland:off-chain:base-avatars:f_glasses_cat_style";
 16
 17        private UserProfile userProfile;
 18        private AvatarEditorHUDController_Mock controller;
 19        private BaseDictionary<string, WearableItem> catalog;
 20        private ColorList skinColorList;
 21        private ColorList hairColorList;
 22        private ColorList eyeColorList;
 23
 1424        protected override bool justSceneSetUp => true;
 25
 26        [UnitySetUp]
 27        protected override IEnumerator SetUp()
 28        {
 1429            yield return base.SetUp();
 30
 1431            if (controller == null)
 32            {
 133                skinColorList = Resources.Load<ColorList>("SkinTone");
 134                hairColorList = Resources.Load<ColorList>("HairColor");
 135                eyeColorList = Resources.Load<ColorList>("EyeColor");
 36
 137                userProfile = ScriptableObject.CreateInstance<UserProfile>();
 38            }
 39
 1440            catalog = AvatarAssetsTestHelpers.CreateTestCatalogLocal();
 1441            controller = new AvatarEditorHUDController_Mock();
 1442            controller.Initialize(userProfile, catalog);
 1443            controller.SetVisibility(true);
 1444            DataStore.i.isPlayerRendererLoaded.Set(true);
 45
 1446            userProfile.UpdateData(new UserProfileModel()
 47            {
 48                name = "name",
 49                email = "mail",
 50                avatar = new AvatarModel()
 51                {
 52                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 53                    wearables = new List<string>() { },
 54                }
 55            }, false);
 1456        }
 57
 58        [UnityTearDown]
 59        protected override IEnumerator TearDown()
 60        {
 1461            controller.Dispose();
 1462            yield return base.TearDown();
 1463        }
 64
 65        [Test]
 66        public void AutofillMandatoryCategoriesIfNotProvided()
 67        {
 168            userProfile.UpdateData(new UserProfileModel()
 69            {
 70                name = "name",
 71                email = "mail",
 72                avatar = new AvatarModel()
 73                {
 74                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 75                    wearables = new List<string>() { },
 76                }
 77            }, false);
 78
 779            var categoriesEquiped = controller.myModel.wearables.Select(x => x.data.category).ToArray();
 1680            foreach (string category in controller.myCategoriesThatMustHaveSelection)
 81            {
 782                if (category != "body_shape")
 83                {
 684                    Assert.Contains(category, categoriesEquiped);
 85                }
 86            }
 187        }
 88
 89        [Test]
 90        public void ReplaceNotSupportedWearablesWhenChangingBodyShape()
 91        {
 192            userProfile.UpdateData(new UserProfileModel()
 93            {
 94                name = "name",
 95                email = "mail",
 96                avatar = new AvatarModel()
 97                {
 98                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 99                    wearables = new List<string>()
 100                    {
 101                        FEMALE_CATGLASSES_ID
 102                    },
 103                }
 104            }, false);
 105
 1106            controller.WearableClicked(WearableLiterals.BodyShapes.MALE);
 107
 9108            Assert.False(controller.myModel.wearables.Any(x => x.id == FEMALE_CATGLASSES_ID));
 1109        }
 110
 111        [Test]
 112        public void LoadUserProfileByConstructor()
 113        {
 1114            userProfile.UpdateData(new UserProfileModel()
 115            {
 116                name = "name",
 117                email = "mail",
 118                avatar = new AvatarModel()
 119                {
 120                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 121                    wearables = new List<string>()
 122                    {
 123                        EYEBROWS_ID,
 124                        "urn:decentraland:off-chain:base-avatars:f_eyes_00",
 125                        "urn:decentraland:off-chain:base-avatars:bear_slippers",
 126                        "urn:decentraland:off-chain:base-avatars:f_african_leggins",
 127                        "urn:decentraland:off-chain:base-avatars:f_mouth_00",
 128                        "urn:decentraland:off-chain:base-avatars:blue_bandana",
 129                        "urn:decentraland:off-chain:base-avatars:bee_t_shirt"
 130                    },
 131                    skinColor = skinColorList.colors[0],
 132                    hairColor = hairColorList.colors[0],
 133                    eyeColor = eyeColorList.colors[0],
 134                }
 135            }, false);
 136
 1137            AssertAvatarModelAgainstAvatarEditorHUDModel(userProfile.avatar, controller.myModel);
 1138        }
 139
 140        [Test]
 141        public void ReactToUserProfileUpdate()
 142        {
 1143            userProfile.UpdateData(new UserProfileModel()
 144            {
 145                name = "name",
 146                email = "mail",
 147                avatar = new AvatarModel()
 148                {
 149                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 150                    wearables = new List<string>()
 151                    {
 152                        EYEBROWS_ID,
 153                        "urn:decentraland:off-chain:base-avatars:f_eyes_00",
 154                        "urn:decentraland:off-chain:base-avatars:bear_slippers",
 155                        "urn:decentraland:off-chain:base-avatars:f_african_leggins",
 156                        "urn:decentraland:off-chain:base-avatars:f_mouth_00",
 157                        "urn:decentraland:off-chain:base-avatars:blue_bandana",
 158                        "urn:decentraland:off-chain:base-avatars:bee_t_shirt"
 159                    },
 160                    skinColor = skinColorList.colors[0],
 161                    hairColor = hairColorList.colors[0],
 162                    eyeColor = eyeColorList.colors[0],
 163                }
 164            }, false);
 165
 1166            AssertAvatarModelAgainstAvatarEditorHUDModel(userProfile.avatar, controller.myModel);
 1167        }
 168
 169        [Test]
 170        public void ProcessClickedBodyShape()
 171        {
 1172            controller.WearableClicked(WearableLiterals.BodyShapes.MALE);
 173
 1174            Assert.AreEqual(WearableLiterals.BodyShapes.MALE, controller.myModel.bodyShape.id);
 1175        }
 176
 177        [Test]
 178        public void ProcessClickedWearables()
 179        {
 1180            controller.WearableClicked(EYEBROWS_ID);
 181
 1182            Assert.AreEqual(EYEBROWS_ID, controller.myModel.wearables.Last().id);
 1183        }
 184
 185        [Test]
 186        public void ProcessSupportedClickedHairColor()
 187        {
 1188            controller.HairColorClicked(hairColorList.colors[3]);
 189
 1190            Assert.AreEqual(hairColorList.colors[3], controller.myModel.hairColor);
 1191        }
 192
 193        [Test]
 194        public void ProcessNotSupportedClickedHairColor()
 195        {
 1196            var current = controller.myModel.hairColor;
 1197            controller.HairColorClicked(hairColorList.colors[0] * new Color(0.2f, 0.4f, 0.2f)); //Getting an arbitrary/i
 198
 1199            Assert.AreEqual(current, controller.myModel.hairColor);
 1200        }
 201
 202        [Test]
 203        public void ProcessSupportedClickedSkinColor()
 204        {
 1205            controller.SkinColorClicked(skinColorList.colors[3]);
 206
 1207            Assert.AreEqual(skinColorList.colors[3], controller.myModel.skinColor);
 1208        }
 209
 210        [Test]
 211        public void ProcessNotSupportedClickedSkinColor()
 212        {
 1213            var current = controller.myModel.skinColor;
 1214            controller.SkinColorClicked(skinColorList.colors[0] * new Color(0.2f, 0.4f, 0.2f)); //Getting an arbitrary/i
 215
 1216            Assert.AreEqual(current, controller.myModel.skinColor);
 1217        }
 218
 219        [Test]
 220        public void ProcessSupportedClickedEyeColor()
 221        {
 1222            controller.EyesColorClicked(eyeColorList.colors[3]);
 223
 1224            Assert.AreEqual(eyeColorList.colors[3], controller.myModel.eyesColor);
 1225        }
 226
 227        [Test]
 228        public void ProcessNotSupportedClickedEyesColor()
 229        {
 1230            var current = controller.myModel.eyesColor;
 1231            controller.EyesColorClicked(eyeColorList.colors[0] * new Color(0.2f, 0.4f, 0.2f)); //Getting an arbitrary/in
 232
 1233            Assert.AreEqual(current, controller.myModel.eyesColor);
 1234        }
 235
 236        [Test]
 237        public void RandomizeOnlyTheSelectedSetOfWearables()
 238        {
 1239            controller.RandomizeWearables();
 240
 1241            Assert.AreEqual(WearableLiterals.BodyShapes.FEMALE, controller.myModel.bodyShape.id);
 8242            var categoriesEquiped = controller.myModel.wearables.Select(x => x.data.category).ToArray();
 16243            foreach (string category in categoriesEquiped)
 244            {
 7245                Assert.Contains(category, controller.myCategoriesToRandomize);
 246            }
 1247        }
 248
 249        [Test]
 250        public void SaveAvatarProperly()
 251        {
 1252            userProfile.UpdateData(new UserProfileModel()
 253            {
 254                name = "name",
 255                email = "mail",
 256                avatar = new AvatarModel()
 257                {
 258                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 259                    wearables = new List<string>()
 260                    {
 261                        EYEBROWS_ID,
 262                        "urn:decentraland:off-chain:base-avatars:f_eyes_00",
 263                        "urn:decentraland:off-chain:base-avatars:bear_slippers",
 264                        "urn:decentraland:off-chain:base-avatars:f_african_leggins",
 265                        "urn:decentraland:off-chain:base-avatars:f_mouth_00",
 266                        "urn:decentraland:off-chain:base-avatars:blue_bandana",
 267                        "urn:decentraland:off-chain:base-avatars:bee_t_shirt"
 268                    },
 269                    skinColor = skinColorList.colors[0],
 270                    hairColor = hairColorList.colors[0],
 271                    eyeColor = eyeColorList.colors[0],
 272                }
 273            }, false);
 274
 1275            controller.WearableClicked(WearableLiterals.BodyShapes.MALE);
 1276            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:eyebrows_01");
 1277            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:eyes_00");
 1278            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:bear_slippers");
 1279            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:basketball_shorts");
 1280            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:mouth_00");
 1281            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:blue_bandana");
 1282            controller.WearableClicked("urn:decentraland:off-chain:base-avatars:black_jacket");
 283
 1284            controller.SaveAvatar(Texture2D.whiteTexture, Texture2D.whiteTexture, Texture2D.whiteTexture, Texture2D.whit
 285
 1286            AssertAvatarModelAgainstAvatarEditorHUDModel(userProfile.avatar, controller.myModel);
 1287        }
 288
 289        private void AssertAvatarModelAgainstAvatarEditorHUDModel(AvatarModel avatarModel, AvatarEditorHUDModel avatarEd
 290        {
 3291            Assert.AreEqual(avatarModel.bodyShape, avatarEditorHUDModel.bodyShape.id);
 292
 3293            Assert.AreEqual(avatarModel.wearables.Count, avatarEditorHUDModel.wearables.Count);
 52294            for (var i = 0; i < avatarModel.wearables.Count; i++)
 295            {
 23296                Assert.AreEqual(avatarModel.wearables[i], avatarEditorHUDModel.wearables[i].id);
 297            }
 298
 3299            Assert.AreEqual(avatarModel.skinColor, avatarEditorHUDModel.skinColor);
 3300            Assert.AreEqual(avatarModel.hairColor, avatarEditorHUDModel.hairColor);
 3301            Assert.AreEqual(avatarModel.eyeColor, avatarEditorHUDModel.eyesColor);
 3302        }
 303    }
 304}
Generated by: ReportGenerator 4.8.9.0
07/13/2021 - 19:40:13
GitHub | www.palmmedia.de

Methods/Properties

justSceneSetUp()
SetUp()
TearDown()
AutofillMandatoryCategoriesIfNotProvided()
ReplaceNotSupportedWearablesWhenChangingBodyShape()
LoadUserProfileByConstructor()
ReactToUserProfileUpdate()
ProcessClickedBodyShape()
ProcessClickedWearables()
ProcessSupportedClickedHairColor()
ProcessNotSupportedClickedHairColor()
ProcessSupportedClickedSkinColor()
ProcessNotSupportedClickedSkinColor()
ProcessSupportedClickedEyeColor()
ProcessNotSupportedClickedEyesColor()
RandomizeOnlyTheSelectedSetOfWearables()
SaveAvatarProperly()
AssertAvatarModelAgainstAvatarEditorHUDModel(AvatarModel, AvatarEditorHUDModel)