Exemple #1
0
        public void RestoreTest_FieldTypeChanged()
        {
            //////////////////////////////////////////////////////////////
            // Setup for this specific test.
            //////////////////////////////////////////////////////////////
            var initialFieldType    = registry.FindByName <UTinyType>("Int32");
            var expectedInitialType = typeof(int);
            var changedFieldType    = registry.FindByName <UTinyType>("EntityReference");
            var expectedChangedType = typeof(UTinyEntity.Reference);

            IMemento state = null;

            // Register for changed events
            caretaker.OnObjectChanged += (originator, memento) =>
            {
                state = memento;
            };

            //////////////////////////////////////////////////////////////
            // 1. Create a component with a single field of type int.
            //////////////////////////////////////////////////////////////
            var componentType = registry.CreateType(UTinyId.New(), "Component", UTinyTypeCode.Component);
            var field         = componentType.CreateField(UTinyId.New(), "Field", (UTinyType.Reference)initialFieldType);

            componentType.Refresh();

            // Check default value
            {
                var defaultValue = componentType.DefaultValue as UTinyObject;
                Assert.IsNotNull(defaultValue);
                Assert.IsTrue(defaultValue.IsDefaultValue);
                Assert.IsTrue(field.FieldType.Equals((UTinyType.Reference)initialFieldType));
                Assert.AreEqual(expectedInitialType, defaultValue["Field"].GetType());
                Assert.AreEqual(defaultValue["Field"], 0);
            }

            Debug.Log($"Initial State: {componentType.Id}: {(componentType.DefaultValue as UTinyObject)["Field"]}");

            // Update to get the initial state; flush changes
            caretaker.Update();
            IMemento initialState = state;

            Assert.NotNull(initialState);

            //////////////////////////////////////////////////////////////
            // 2- Change the field type to be of EntityReference.
            //////////////////////////////////////////////////////////////
            field.FieldType = (UTinyType.Reference)changedFieldType;
            componentType.Refresh();

            // Check default value
            {
                var defaultValue = componentType.DefaultValue as UTinyObject;
                Assert.IsNotNull(defaultValue);
                Assert.IsTrue(defaultValue.IsDefaultValue);
                Assert.IsTrue(field.FieldType.Equals((UTinyType.Reference)changedFieldType));
                Assert.AreEqual(expectedChangedType, defaultValue["Field"].GetType());
                Assert.AreEqual(defaultValue["Field"], UTinyEntity.Reference.None);
            }

            Debug.Log($"Changed State: {componentType.Id}: {(componentType.DefaultValue as UTinyObject)["Field"]}");

            // Update to get the changed state; flush changes
            caretaker.Update();
            IMemento changedState = state;

            Assert.NotNull(changedState);
            Assert.AreNotEqual(initialState, changedState);
            Assert.IsTrue(initialState.Version < changedState.Version);

            //////////////////////////////////////////////////////////////
            // 3 - Restore it back to its initial field type (Undo).
            //////////////////////////////////////////////////////////////
            Debug.Log("Undo");
            Debug.Log($"Before: {componentType.Id}: {(componentType.DefaultValue as UTinyObject)["Field"]}");
            componentType.Restore(initialState);
            // Note: Restoring is not in-place, so we need to re-set the references
            componentType = registry.FindById <UTinyType>(componentType.Id);
            componentType.Refresh();
            field = componentType.Fields[0];
            Debug.Log($"After: {componentType.Id}: {(componentType.DefaultValue as UTinyObject)["Field"]}");
            // Check default value
            {
                var defaultValue = componentType.DefaultValue as UTinyObject;
                Assert.IsNotNull(defaultValue);
                Assert.IsTrue(defaultValue.IsDefaultValue);
                Assert.IsTrue(field.FieldType.Equals((UTinyType.Reference)initialFieldType));
                Assert.AreEqual(expectedInitialType, defaultValue["Field"].GetType());
                Assert.AreEqual(defaultValue["Field"], 0);
            }

            // Update to get the changed state; flush changes
            caretaker.Update();

            //////////////////////////////////////////////////////////////
            // 4- Restore the field type change (Redo).
            //////////////////////////////////////////////////////////////
            Debug.Log("Redo");
            Debug.Log($"Before: {componentType.Id}: {(componentType.DefaultValue as UTinyObject)["Field"]}");
            componentType.Restore(changedState);
            // Note: Restoring is not in-place, so we need to re-set the references
            componentType = registry.FindById <UTinyType>(componentType.Id);
            componentType.Refresh();
            field = componentType.Fields[0];
            Debug.Log($"After: {componentType.Id}: {(componentType.DefaultValue as UTinyObject)["Field"]}");
            // Check default value
            {
                var defaultValue = componentType.DefaultValue as UTinyObject;
                Assert.IsNotNull(defaultValue);
                Assert.IsTrue(defaultValue.IsDefaultValue);
                Assert.IsTrue(field.FieldType.Equals((UTinyType.Reference)changedFieldType));
                Assert.AreEqual(expectedChangedType, defaultValue["Field"].GetType());
                Assert.AreEqual(defaultValue["Field"], UTinyEntity.Reference.None);
            }
        }