public ZenjectSceneLoader(
     [InjectOptional] SceneContext sceneRoot,
     ProjectKernel projectKernel)
 {
     _projectKernel  = projectKernel;
     _sceneContainer = sceneRoot == null ? null : sceneRoot.Container;
 }
 public ZenjectSceneLoader(
     SceneContext sceneRoot,
     ProjectKernel projectKernel)
 {
     _projectKernel  = projectKernel;
     _sceneContainer = sceneRoot.Container;
 }
 public SceneContextRegistryAdderAndRemover(
     SceneContext sceneContext,
     SceneContextRegistry registry)
 {
     _registry     = registry;
     _sceneContext = sceneContext;
 }
Exemple #4
0
        public void Remove(SceneContext context)
        {
            bool removed = _map.Remove(context.gameObject.scene);

            if (!removed)
            {
                ModestTree.Log.Warn("Failed to remove SceneContext from SceneContextRegistry");
            }
        }
Exemple #5
0
        public virtual void SetUp()
        {
            _hasStarted   = false;
            _isValidating = CurrentTestHasAttribute <ValidateOnlyAttribute>();

            ProjectContext.ValidateOnNextRun = _isValidating;

            _sceneContext = new GameObject("SceneContext").AddComponent <SceneContext>();
            _sceneContext.ParentNewObjectsUnderRoot = true;
            // This creates the container but does not resolve the roots yet
            _sceneContext.Install();
        }
Exemple #6
0
        public IEnumerator LoadScenes(params string[] sceneNames)
        {
            Assert.That(!_hasLoadedScene, "Attempted to load scene twice!");
            _hasLoadedScene = true;

            // Clean up any leftovers from previous test
            ZenjectTestUtil.DestroyEverythingExceptTestRunner(false);

            Assert.That(SceneContainers.IsEmpty());

            for (int i = 0; i < sceneNames.Length; i++)
            {
                var sceneName = sceneNames[i];

                Assert.That(Application.CanStreamedLevelBeLoaded(sceneName),
                            "Cannot load scene '{0}' for test '{1}'.  The scenes used by SceneTestFixture derived classes must be added to the build settings for the test to work",
                            sceneName, GetType());

                Log.Info("Loading scene '{0}' for testing", sceneName);

                var loader =
                    SceneManager.LoadSceneAsync(sceneName, i == 0 ? LoadSceneMode.Single : LoadSceneMode.Additive);

                while (!loader.isDone)
                {
                    yield return(null);
                }

                SceneContext sceneContext = null;

                if (ProjectContext.HasInstance)
                // ProjectContext might be null if scene does not have a scene context
                {
                    var scene = SceneManager.GetSceneByName(sceneName);

                    sceneContext = ProjectContext.Instance.Container.Resolve <SceneContextRegistry>()
                                   .TryGetSceneContextForScene(scene);
                }

                _sceneContainers.Add(sceneContext == null ? null : sceneContext.Container);
            }

            _sceneContainer = _sceneContainers.Where(x => x != null).LastOrDefault();

            if (_sceneContainer != null)
            {
                _sceneContainer.Inject(this);
            }
        }
        public DiContainer TryGetContainerForScene(Scene scene)
        {
            if (scene == ProjectContext.Instance.gameObject.scene)
            {
                return(ProjectContext.Instance.Container);
            }

            SceneContext sceneContext = TryGetSceneContextForScene(scene);

            if (sceneContext != null)
            {
                return(sceneContext.Container);
            }

            return(null);
        }
        public virtual void SetUp()
        {
            // Don't clear the scene to allow tests to initialize the scene how they
            // want to set it up manually in their own [Setup] method (eg. TestFromComponentInChildren)
            // Also, I think unity might already clear the scene anyway?
            //ClearScene();

            _hasStarted   = false;
            _isValidating = CurrentTestHasAttribute <ValidateOnlyAttribute>();

            ProjectContext.ValidateOnNextRun = _isValidating;

            _sceneContext = new GameObject("SceneContext").AddComponent <SceneContext>();
            _sceneContext.ParentNewObjectsUnderRoot = true;
            // This creates the container but does not resolve the roots yet
            _sceneContext.Install();
        }
        public IEnumerator LoadScenes(params string[] scenePaths)
        {
            Assert.That(!_hasLoadedScene, "Attempted to load scene twice!");
            _hasLoadedScene = true;

            // Clean up any leftovers from previous test
            ZenjectTestUtil.DestroyEverythingExceptTestRunner(false);

            Assert.That(SceneContainers.IsEmpty());

            for (var i = 0; i < scenePaths.Length; i++)
            {
                var scenePath = scenePaths[i];

                Log.Info("Loading scene '{0}' for testing", scenePath);

                var loader =
                    EditorSceneManager.LoadSceneAsyncInPlayMode(scenePath, new LoadSceneParameters(
                                                                    i == 0 ? LoadSceneMode.Single : LoadSceneMode.Additive
                                                                    ));

                while (!loader.isDone)
                {
                    yield return(null);
                }

                SceneContext sceneContext = null;

                // ProjectContext might be null if scene does not have a scene context
                if (ProjectContext.HasInstance)
                {
                    var scene = SceneManager.GetSceneByPath(scenePath);

                    sceneContext = ProjectContext.Instance.Container.Resolve <SceneContextRegistry>()
                                   .TryGetSceneContextForScene(scene);
                }

                _sceneContainers.Add(sceneContext == null ? null : sceneContext.Container);
            }

            SceneContainer = _sceneContainers.LastOrDefault(x => x != null);

            SceneContainer?.Inject(this);
        }
Exemple #10
0
        public static Context GetContext(Scene scene, Type type, bool create)
        {
            Assert.IsNotNull(scene);
            Assert.DerivesFromOrEqual <Context>(type);

            if (type.DerivesFromOrEqual <ProjectContext>())
            {
                return(Zenject.ProjectContext.Instance);
            }

            var contextType      = (type == typeof(Context)) ? typeof(SceneContext) : type;
            var contextComponent = GameObject
                                   .FindObjectsOfType(contextType)
                                   .Cast <Component>()
                                   .FirstOrDefault(comp => comp.gameObject.scene == scene);

            if (create && contextComponent == null)
            {
                if (contextType == typeof(SceneContext))
                {
                    contextComponent = SceneContext.Create();
                }
                else if (contextType.DerivesFromOrEqual <SceneContext>())
                {
                    _sceneContextStaticAutoRunBindingField.SetValue(null, false);
                    contextComponent = new GameObject(typeof(SceneContext).Name).AddComponent(contextType);
                    Assert.That((bool)_sceneContextStaticAutoRunBindingField.GetValue(null)); // Should be reset
                }
                else
                {
                    var contextParentContainer = GetContainer(scene, typeof(SceneContext), true);
                    var contextGameObject      = new GameObject(contextType.Name);
                    contextComponent = contextParentContainer.InstantiateComponent(contextType, contextGameObject, new object[0]);
                }

                if (contextComponent.gameObject.scene != scene)
                {
                    SceneManager.MoveGameObjectToScene(contextComponent.gameObject, scene);
                }
            }

            return(contextComponent as Context);
        }
Exemple #11
0
        protected void PreInstall()
        {
            Assert.That(!_hasStartedInstall, "Called PreInstall twice in test '{0}'!", TestContext.CurrentContext.Test.Name);
            _hasStartedInstall = true;

            Assert.That(!ProjectContext.HasInstance);

            var shouldValidate = CurrentTestHasAttribute <ValidateOnlyAttribute>();

            ProjectContext.ValidateOnNextRun = shouldValidate;

            Assert.IsNull(_sceneContext);

            _sceneContext = SceneContext.Create();
            _sceneContext.Install();

            Assert.That(ProjectContext.HasInstance);
            Assert.IsEqual(shouldValidate, ProjectContext.Instance.Container.IsValidating);
            Assert.IsEqual(shouldValidate, _sceneContext.Container.IsValidating);
        }
Exemple #12
0
        void DestroyEverythingInternal(bool immediate)
        {
            if (_sceneContext != null)
            {
                // We need to use DestroyImmediate so that all the IDisposable's etc get processed immediately before
                // next test runs
                if (immediate)
                {
                    GameObject.DestroyImmediate(_sceneContext.gameObject);
                }
                else
                {
                    GameObject.Destroy(_sceneContext.gameObject);
                }

                _sceneContext = null;
            }

            ZenjectTestUtil.DestroyEverythingExceptTestRunner(immediate);
            StaticContext.Clear();
        }
Exemple #13
0
        protected void DestroyAll()
        {
            Assert.That(!_hasDestroyedAll, "Called DestroyAll twice in test '{0}'!", TestContext.CurrentContext.Test.Name);
            _hasDestroyedAll = true;

            Assert.That(_hasStartedInstall,
                        "Called DestroyAll but did not call PreInstall (or SkipInstall) in test '{0}'!", TestContext.CurrentContext.Test.Name);

            // We need to use DestroyImmediate so that all the IDisposable's etc get processed immediately before
            // next test runs
            GameObject.DestroyImmediate(_sceneContext.gameObject);
            _sceneContext = null;

            var allRootObjects = new List <GameObject>();

            // We want to clear all objects across all scenes to ensure the next test is not affected
            // at all by previous tests
            // TODO: How does this handle cases where the test loads other scenes?
            for (int i = 0; i < SceneManager.sceneCount; i++)
            {
                allRootObjects.AddRange(
                    SceneManager.GetSceneAt(i).GetRootGameObjects());
            }

            // We also want to destroy any objects marked DontDestroyOnLoad, especially ProjectContext
            allRootObjects.AddRange(ProjectContext.Instance.gameObject.scene.GetRootGameObjects());

            foreach (var rootObj in allRootObjects)
            {
                // Make sure not to destroy the unity test runner objects that it adds
                if (!_unityTestRunnerObjects.Contains(rootObj))
                {
                    // Use DestroyImmediate for other objects too just to ensure we are fully
                    // cleaned up before the next test starts
                    GameObject.DestroyImmediate(rootObj);
                }
            }
        }
Exemple #14
0
 public void Add(SceneContext context)
 {
     Assert.That(!_map.ContainsKey(context.gameObject.scene));
     _map.Add(context.gameObject.scene, context);
 }
 public void Remove(SceneContext context)
 {
     _map.RemoveWithConfirm(context.gameObject.scene);
 }
 public ZenjectSceneLoader(SceneContext sceneRoot)
 {
     _sceneContainer = sceneRoot.Container;
 }
 public ZenjectSceneLoader(SceneContext sceneRoot)
 {
     _sceneContainer = sceneRoot.Container;
 }