public void ProcessTemplateCompleter_Exercise()
        {
            // Arrange
            var ps = BaseTests.PrepPowerShell();

            ps.Invoke <string>().Returns(this._templates);
            ProcessTemplateCache.Cache.Shell = ps;
            ProcessTemplateCache.Invalidate();

            var target = new ProcessTemplateCompleter(ps);
            var fakeBoundParameters = new Dictionary <string, string>();

            // Act
            var actual = target.CompleteArgument(string.Empty, string.Empty, string.Empty, null, fakeBoundParameters);

            // Assert
            Assert.AreEqual(5, actual.Count());
            var e = actual.GetEnumerator();

            e.MoveNext();
            Assert.AreEqual("Agile", e.Current.CompletionText, "Agile");
            e.MoveNext();
            Assert.AreEqual("CMMI", e.Current.CompletionText, "CMMI");
            e.MoveNext();
            Assert.AreEqual("Scrum", e.Current.CompletionText, "Scrum");
            e.MoveNext();
            Assert.AreEqual("'Scrum With Space'", e.Current.CompletionText, "Scrum With Space");
            e.MoveNext();
            Assert.AreEqual("Basic", e.Current.CompletionText, "Basic");
        }
        public void ProcessTemplateValidateAttribute_Invalid_Value_Throws()
        {
            // Arrange
            var ps = BaseTests.PrepPowerShell();

            ps.Invoke <string>().Returns(this._templates);
            ProcessTemplateCache.Cache.Shell = ps;
            ProcessTemplateCache.Invalidate();

            // Act
            // Assert
            Assert.ThrowsException <ValidationMetadataException>(() => this.Validate("Test", null));
        }
        public void ProcessTemplateCache_Update_With_Empty_List()
        {
            // Arrange
            var expected = 0;
            var ps       = BaseTests.PrepPowerShell();

            ProcessTemplateCache.Cache.Shell = ps;

            // Act
            ProcessTemplateCache.Update(new List <string>());

            // Assert
            Assert.AreEqual(expected, ProcessTemplateCache.Cache.Values.Count);
        }
        public void ProcessTemplateCache_Update_Returns_Null()
        {
            // Arrange
            var expected = 0;
            var ps       = BaseTests.PrepPowerShell();

            ProcessTemplateCache.Cache.Shell = ps;

            // Act
            ProcessTemplateCache.Update(null);

            // Assert
            Assert.AreEqual(expected, ProcessTemplateCache.Cache.Values.Count);
        }
        public void ProcessTemplateValidateAttribute_Empty_Cache_Does_Not_Throw()
        {
            // Arrange
            var ps = BaseTests.PrepPowerShell();

            ps.Invoke <string>().Returns(this._empty);
            ProcessTemplateCache.Cache.Shell = ps;
            ProcessTemplateCache.Invalidate();

            // Act
            this.Validate("Agile", null);

            // Assert
        }
        public void ProcessTemplateCache_Update_With_Null_List()
        {
            // Arrange
            var expected = 5;
            var ps       = BaseTests.PrepPowerShell();

            ps.Invoke <string>().Returns(this._items);
            ProcessTemplateCache.Cache.Shell = ps;

            // Act
            ProcessTemplateCache.Update(null);

            // Assert
            Assert.AreEqual(expected, ProcessTemplateCache.Cache.Values.Count);
        }
        public void ProcessTemplateCache_GetCurrent()
        {
            // Arrange
            var expected = 5;
            var ps       = BaseTests.PrepPowerShell();

            ps.Invoke <string>().Returns(this._items);
            ProcessTemplateCache.Cache.Shell = ps;
            ProcessTemplateCache.Invalidate();

            // Act
            var actual = ProcessTemplateCache.GetCurrent();

            // Assert
            Assert.AreEqual(expected, actual.Count());
        }
        public void ProcessTemplateCache_HasCacheExpired()
        {
            // Arrange
            var expected = true;

            // Act
            ProcessTemplateCache.Invalidate();

            // Assert
            Assert.AreEqual(expected, ProcessTemplateCache.HasCacheExpired, "Cache should be expired");

            // Act
            ProcessTemplateCache.Update(new List <string>());

            // Assert
            Assert.AreNotEqual(expected, ProcessTemplateCache.HasCacheExpired, "Cache should not be expired");
        }