public NSpecTestContainer(
            ITestContainerDiscoverer containerDiscoverer,
            string sourcePath,
            IEnumerable <Guid> debugEngines,
            IFileService fileService)
        {
            ValidateArg.NotNull(containerDiscoverer, "containerDiscoverer");
            ValidateArg.NotNullOrEmpty(sourcePath, "sourcePath");
            ValidateArg.NotNull(debugEngines, "debugEngines");
            ValidateArg.NotNull(fileService, "fileService");

            this.containerDiscoverer = containerDiscoverer;
            this.sourcePath          = sourcePath;
            this.debugEngines        = debugEngines;
            this.fileService         = fileService;

            if (fileService.Exists(sourcePath))
            {
                timeStamp = fileService.LastModified(sourcePath);
            }
            else
            {
                timeStamp = DateTime.MinValue;
            }
        }
Example #2
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source, DateTime timeStamp, Architecture architecture)
 {
     Discoverer    = discoverer;
     Source        = source;
     _timeStamp    = timeStamp;
     _architecture = architecture;
 }
Example #3
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source, DateTime timeStamp, Architecture architecture)
 {
     this.Discoverer     = discoverer;
     this.Source         = source;
     this.TargetPlatform = architecture;
     this.timeStamp      = timeStamp;
 }
Example #4
0
 public KarmaTestContainer(ITestContainerDiscoverer discoverer, string source, IEnumerable <Guid> debugEngines)
 {
     this.Source          = source;
     this.DebugEngines    = debugEngines;
     this._discoverer     = discoverer;
     this.TargetFramework = FrameworkVersion.None;
     this.TargetPlatform  = Architecture.AnyCPU;
     this._timeStamp      = DateTime.Now;
 }
Example #5
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source, PythonProject project, int version, Architecture architecture, TestCaseInfo[] testCases)
 {
     Discoverer    = discoverer;
     Source        = source;
     _version      = version;
     _project      = project;
     _architecture = architecture;
     _testCases    = testCases;
 }
 public KarmaTestContainer(ITestContainerDiscoverer discoverer, string source, IEnumerable<Guid> debugEngines)
 {
     this.Source = source;
     this.DebugEngines = debugEngines;
     this._discoverer = discoverer;
     this.TargetFramework = FrameworkVersion.None;
     this.TargetPlatform = Architecture.AnyCPU;
     this._timeStamp = DateTime.Now;
 }
 public tSQLtTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri, IEnumerable <Guid> debugEngines)
 {
     this.Source          = source;
     this.ExecutorUri     = executorUri;
     this.DebugEngines    = debugEngines;
     this.discoverer      = discoverer;
     this.TargetFramework = FrameworkVersion.None;
     this.TargetPlatform  = Architecture.AnyCPU;
     this.timeStamp       = GetTimeStamp();
 }
Example #8
0
 public JsonTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri, IEnumerable<Guid> debugEngines)
 {
     this.Source = source;
     this.ExecutorUri = executorUri;
     this.DebugEngines = debugEngines;
     this.discoverer = discoverer;
     this.TargetFramework = FrameworkVersion.None;
     this.TargetPlatform = Architecture.AnyCPU;
     this.timeStamp = this.GetTimeStamp();
 }
        public void Add(ITestContainerDiscoverer containerDiscoverer, string path)
        {
            Remove(path);
            if (IsTestFile(path))
            {
                QmlTestContainer container = new QmlTestContainer(containerDiscoverer,
                                                                  path.ToLowerInvariant());

                cache.Add(container);
            }
        }
 public PowerShellTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri,
     IEnumerable<Guid> debugEngines)
 {
     Source = source;
     ExecutorUri = executorUri;
     DebugEngines = debugEngines;
     _discoverer = discoverer;
     TargetFramework = FrameworkVersion.None;
     TargetPlatform = Architecture.AnyCPU;
     _timeStamp = GetTimeStamp();
 }
 public PowerShellTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri,
                                IEnumerable <Guid> debugEngines)
 {
     Source          = source;
     ExecutorUri     = executorUri;
     DebugEngines    = debugEngines;
     _discoverer     = discoverer;
     TargetFramework = FrameworkVersion.None;
     TargetPlatform  = Architecture.AnyCPU;
     _timeStamp      = GetTimeStamp();
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="TestContainer"/> class.
        /// </summary>
        /// <param name="discoverer">The discoverer.</param>
        /// <param name="source">The source.</param>
        /// <param name="debugEngines">The debug engines.</param>
        public TestContainer(ITestContainerDiscoverer discoverer, string source, IEnumerable <Guid> debugEngines)
        {
            if (string.IsNullOrWhiteSpace(source))
            {
                return;
            }

            this.Discoverer   = discoverer;
            this.Source       = source;
            this.DebugEngines = debugEngines;
        }
Example #13
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source, string projectHome, string projectName, int version, Architecture architecture, bool isWorkspace)
 {
     Discoverer     = discoverer;
     Source         = source; // Make sure source matches discovery new TestCase source.
     Version        = version;
     Project        = projectHome;
     ProjectName    = projectName;
     TargetPlatform = architecture;
     _timeStamp     = GetTimeStamp();
     _isWorkspace   = isWorkspace;
 }
Example #14
0
        /// <summary>
        /// Initializes a new <see cref="PowerShellTestContainer"/>.
        /// </summary>
        /// <param name="containerDiscoverer">The associated discoverer</param>
        /// <param name="scriptPath">A string representing the container source, ie. a file path</param>
        /// <param name="project">A source's parent project</param>
        /// <param name="debugEngines">Any debugging engines</param>
        public PowerShellTestContainer(ITestContainerDiscoverer containerDiscoverer, string scriptPath, IVsProject project, IEnumerable <Guid> debugEngines)
        {
            _containerDiscoverer = ValidateArg.NotNull(containerDiscoverer, "containerDiscoverer");;
            _scriptPath          = ValidateArg.NotNull(scriptPath, "scriptPath");
            Project = ValidateArg.NotNull(project, "project");

            _projectFile    = project.Info().File;
            TargetFramework = FrameworkVersion.None;
            TargetPlatform  = Architecture.AnyCPU;
            DebugEngines    = debugEngines;

            _timestamp = GetTimestamp();
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="TestContainer"/> class.
        /// </summary>
        /// <param name="discoverer">The discoverer.</param>
        /// <param name="source">The source.</param>
        public TestContainer(ITestContainerDiscoverer discoverer, string source)
            : this(discoverer, source, Enumerable.Empty <Guid>())
        {
            if (string.IsNullOrWhiteSpace(source))
            {
                return;
            }

            this.Discoverer      = discoverer;
            this.Source          = source;
            this.DebugEngines    = new List <Guid>();
            this.lastKnownChange = this.GetTimeStamp();
        }
Example #16
0
        public JsTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri, IEnumerable <Guid> debugEngines)
        {
            ValidateArg.NotNullOrEmpty(source, "source");
            ValidateArg.NotNull(executorUri, "executorUri");
            ValidateArg.NotNull(debugEngines, "debugEngines");
            ValidateArg.NotNull(discoverer, "discoverer");

            this.Source          = source;
            this.ExecutorUri     = executorUri;
            this.TargetFramework = FrameworkVersion.None;
            this.TargetPlatform  = Architecture.AnyCPU;
            this.DebugEngines    = debugEngines;
            this.timeStamp       = GetTimeStamp();
            this.discoverer      = discoverer;
        }
Example #17
0
        public JsTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri, IEnumerable<Guid> debugEngines)
        {
            ValidateArg.NotNullOrEmpty(source, "source");
            ValidateArg.NotNull(executorUri, "executorUri");
            ValidateArg.NotNull(debugEngines, "debugEngines");
            ValidateArg.NotNull(discoverer, "discoverer");

            this.Source = source;
            this.ExecutorUri = executorUri;
            this.TargetFramework = FrameworkVersion.None;
            this.TargetPlatform = Architecture.AnyCPU;
            this.DebugEngines = debugEngines;
            this.timeStamp = GetTimeStamp();
            this.discoverer = discoverer;
        }
Example #18
0
        public void AddTestContainer(ITestContainerDiscoverer discoverer, string path)
        {
            if (!Path.GetExtension(path).Equals(PythonConstants.FileExtension, StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            _containers[path] = new TestContainer(
                discoverer,
                path,
                _projectHome,
                ProjectName,
                Architecture,
                IsWorkspace
                );
        }
        public virtual void before_each()
        {
            autoSubstitute = new AutoSubstitute();

            containerDiscoverer = autoSubstitute.Resolve <ITestContainerDiscoverer>();

            debugEngines = new Guid[] { Guid.NewGuid(), Guid.NewGuid() };

            fileService = autoSubstitute.Resolve <IFileService>();

            someTime = new DateTime(2015, 10, 21);

            fileService.Exists(Arg.Any <string>()).Returns(true);
            fileService.LastModified(Arg.Any <string>()).Returns(someTime);

            container = new NSpecTestContainer(containerDiscoverer, sourcePath, debugEngines, fileService);
        }
Example #20
0
 public TestContainer(
     ITestContainerDiscoverer discoverer,
     string source,
     string projectHome,
     string projectName,
     Architecture architecture,
     bool isWorkspace
     )
 {
     Discoverer     = discoverer;
     Source         = source; // Make sure source matches discovery new TestCase source.
     Project        = projectHome;
     ProjectName    = projectName;
     TargetPlatform = architecture;
     _lastWriteTime = GetLastWriteTimeStamp();
     _cachedTime    = DateTime.Now;
     _isWorkspace   = isWorkspace;
 }
Example #21
0
        public async Task TestBuildingAndClearingProjectMapConcurrently()
        {
            ITestContainerDiscoverer dummyDiscoverer = null;
            var           projectMap   = new ConcurrentDictionary <string, ProjectInfo>();
            var           projectName  = "dummyName";
            PythonProject dummyProject = new MockPythonProject("dummyHome", projectName);

            //Simulate rebuid workspace
            projectMap[projectName] = new ProjectInfo(dummyProject);

            var rebuildTasks = Enumerable.Range(1, 10)
                               .Select(i => Task.Run(async
                                                         () =>
            {
                projectMap.Clear();
                projectMap[projectName] = new ProjectInfo(dummyProject);
                foreach (int j in Enumerable.Range(1, 1000))
                {
                    projectMap[projectName].AddTestContainer(dummyDiscoverer, j.ToString() + ".py");
                }

                await Task.Delay(100);
            }
                                                     )
                                       );

            //Simulate Get TestContainers
            var iterateTasks = Enumerable.Range(1, 100)
                               .Select(i => Task.Run(async
                                                         () =>
            {
                var items = projectMap.Values.SelectMany(p => p.GetAllContainers()).ToList();
                await Task.Delay(10);
            }
                                                     )
                                       );

            await Task.WhenAll(rebuildTasks.Concat(iterateTasks));

            Assert.AreEqual(1000, projectMap[projectName].GetAllContainers().Count());
        }
        public QmlTestContainerCache(
            ITestContainerDiscoverer testContainerDiscoverer,
            IServiceProvider serviceProvider,
            ISolutionEventsListener solutionListener,
            ITestFilesUpdateWatcher testFilesUpdateWatcher,
            ITestFileAddRemoveListener testFilesAddRemoveListener)
        {
            this.solutionListener           = solutionListener;
            this.serviceProvider            = serviceProvider;
            this.testFilesUpdateWatcher     = testFilesUpdateWatcher;
            this.testFilesAddRemoveListener = testFilesAddRemoveListener;
            this.testContainerDiscoverer    = testContainerDiscoverer;

            this.solutionListener.SolutionUnloaded          += OnSolutionUnloaded;
            this.solutionListener.SolutionProjectChanged    += OnSolutionProjectChanged;
            this.testFilesUpdateWatcher.FileChangedEvent    += OnProjectItemChanged;
            this.testFilesAddRemoveListener.TestFileChanged += OnProjectItemChanged;

            this.solutionListener.StartListeningForChanges();
            this.testFilesAddRemoveListener.StartListeningForTestFileChanges();
        }
Example #23
0
        public void AddTestContainer(ITestContainerDiscoverer discoverer, string path)
        {
            if (!Path.GetExtension(path).Equals(PythonConstants.FileExtension, StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            TestContainer existing;

            if (!TryGetContainer(path, out existing))
            {
                _containers[path] = new TestContainer(
                    discoverer,
                    path,
                    _projectHome,
                    ProjectName,
                    version: 0,
                    Architecture,
                    IsWorkspace
                    );
            }
            else
            {
                RemoveTestContainer(path);

                _containers[path] = new TestContainer(
                    discoverer,
                    path,
                    _projectHome,
                    ProjectName,
                    version: existing.Version + 1,
                    Architecture,
                    IsWorkspace
                    );
            }
        }
 private static IVSTestContainer CreateContainer(ITestContainerDiscoverer discoverer, string source, IVsProject project)
 {
     return(Mock.Of <IVSTestContainer>(c => c.Discoverer == discoverer && c.Source == source && c.Project == project));
 }
 public CTestContainer(ITestContainerDiscoverer discoverer, string source)
 {
     Source = source;
     Discoverer = discoverer;
 }
Example #26
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source, DateTime timeStamp, Architecture architecture) {
     Discoverer = discoverer;
     Source = source;
     _timeStamp = timeStamp;
     _architecture = architecture;
 }
Example #27
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source)
 {
     this.Discoverer = discoverer;
     this.Source = source;
     this.CreatedTime = DateTime.Now;
 }
Example #28
0
 public CTestContainer(ITestContainerDiscoverer discoverer, string source)
 {
     Source     = source;
     Discoverer = discoverer;
 }
Example #29
0
 public TestContainer(ITestContainerDiscoverer testContainerDiscoverer, string source)
 {
     Discoverer = testContainerDiscoverer;
     Source = source;
 }
 public PackageJsonTestContainer(ITestContainerDiscoverer discoverer, string source, string testRoot)
 {
     this.Discoverer = discoverer;
     this.Source     = source;
     this.TestRoot   = testRoot;
 }
 // ctor
 public TestContainer(ITestContainerDiscoverer discoverer, string testFilename, DateTime timeStamp)
 {
     this.Discoverer = discoverer;
     this.Source     = testFilename;                                                             // full path filename for test file (e.g. MyTests.spec.ts)
     this._timeStamp = timeStamp;
 }
Example #32
0
 public QmlTestContainer(ITestContainerDiscoverer containerDiscoverer, string source)
 {
     this.containerDiscoverer = containerDiscoverer;
     this.Source    = source;
     this.timeStamp = GetTimeStamp();
 }
 public TSTestContainer(ITestContainerDiscoverer discoverer, string source)
 {
     this.discoverer = discoverer;
     this.source = source;
     this.timeStamp = GetTimeStamp();
 }
Example #34
0
 public KarmaTestContainer(ITestContainerDiscoverer discoverer, string source)
     : this(discoverer, source, Enumerable.Empty <Guid>())
 {
 }
Example #35
0
 public JsTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri)
     : this(discoverer, source, executorUri, Enumerable.Empty<Guid>())
 {
 }
 public TestContainer(ITestContainerDiscoverer discoverer, string source, DateTime timeStamp)
 {
     this.Discoverer = discoverer;
     this.Source     = source;
     this.timeStamp  = timeStamp;
 }
 public PowerShellTestContainer(ITestContainerDiscoverer discoverer, string source, Uri executorUri)
     : this(discoverer, source, executorUri, Enumerable.Empty <Guid>())
 {
 }
Example #38
0
 public TestContainer(ITestContainerDiscoverer testContainerDiscoverer, string source, DateTime timestamp)
 {
     Discoverer = testContainerDiscoverer;
     Source     = source;
     _timestamp = timestamp;
 }
 public CucumberJsTestContainer(ITestContainerDiscoverer discoverer, string source)
 {
     this.discoverer = discoverer;
     this.source = source;
     this.timeStamp = this.GetTimeStamp();
 }
Example #40
0
 public TestContainer(ITestContainerDiscoverer discoverer, string source)
 {
     this.Discoverer  = discoverer;
     this.Source      = source;
     this.CreatedTime = DateTime.Now;
 }
Example #41
0
 /// <summary>
 /// Initializes a new <see cref="PowerShellTestContainer"/>.
 /// </summary>
 /// <param name="containerDiscoverer">The associated discoverer</param>
 /// <param name="scriptPath">A string representing the container source, ie. a file path</param>
 /// <param name="project">A source's parent project</param>
 public PowerShellTestContainer(ITestContainerDiscoverer containerDiscoverer, string scriptPath, IVsProject project)
     : this(containerDiscoverer, scriptPath, project, Enumerable.Empty <Guid>())
 {
 }
 public KarmaTestContainer(ITestContainerDiscoverer discoverer, string source)
     : this(discoverer, source, Enumerable.Empty<Guid>())
 {
 }