diff --git a/src/client/common/process/processFactory.ts b/src/client/common/process/processFactory.ts
index f217994cd7d7..d6da78721138 100644
--- a/src/client/common/process/processFactory.ts
+++ b/src/client/common/process/processFactory.ts
@@ -5,7 +5,6 @@
 
 import { inject, injectable } from 'inversify';
 import { Uri } from 'vscode';
-import { IServiceContainer } from '../../ioc/types';
 import { IDisposableRegistry } from '../types';
 import { IEnvironmentVariablesProvider } from '../variables/types';
 import { ProcessService } from './proc';
@@ -13,18 +12,16 @@ import { IBufferDecoder, IProcessLogger, IProcessService, IProcessServiceFactory
 
 @injectable()
 export class ProcessServiceFactory implements IProcessServiceFactory {
-    private envVarsService: IEnvironmentVariablesProvider;
-    private processLogger: IProcessLogger;
-    constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
-        this.envVarsService = serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
-        this.processLogger = serviceContainer.get<IProcessLogger>(IProcessLogger);
-    }
+    constructor(
+        @inject(IEnvironmentVariablesProvider) private readonly envVarsService: IEnvironmentVariablesProvider,
+        @inject(IProcessLogger) private readonly processLogger: IProcessLogger,
+        @inject(IBufferDecoder) private readonly decoder: IBufferDecoder,
+        @inject(IDisposableRegistry) private readonly disposableRegistry: IDisposableRegistry
+    ) {}
     public async create(resource?: Uri): Promise<IProcessService> {
         const customEnvVars = await this.envVarsService.getEnvironmentVariables(resource);
-        const decoder = this.serviceContainer.get<IBufferDecoder>(IBufferDecoder);
-        const disposableRegistry = this.serviceContainer.get<IDisposableRegistry>(IDisposableRegistry);
-        const proc: IProcessService = new ProcessService(decoder, customEnvVars);
-        disposableRegistry.push(proc);
+        const proc: IProcessService = new ProcessService(this.decoder, customEnvVars);
+        this.disposableRegistry.push(proc);
         return proc.on('exec', this.processLogger.logProcess.bind(this.processLogger));
     }
 }
diff --git a/src/client/debugger/debugAdapter/Common/processServiceFactory.ts b/src/client/debugger/debugAdapter/Common/processServiceFactory.ts
index cc969f52d8fd..b6facbdf39d6 100644
--- a/src/client/debugger/debugAdapter/Common/processServiceFactory.ts
+++ b/src/client/debugger/debugAdapter/Common/processServiceFactory.ts
@@ -7,14 +7,13 @@ import { inject, injectable } from 'inversify';
 import { ProcessService } from '../../../common/process/proc';
 import { IBufferDecoder, IProcessService, IProcessServiceFactory } from '../../../common/process/types';
 import { IDisposableRegistry } from '../../../common/types';
-import { IServiceContainer } from '../../../ioc/types';
 
 @injectable()
 export class DebuggerProcessServiceFactory implements IProcessServiceFactory {
-    constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) { }
+    constructor(@inject(IBufferDecoder) private readonly decoder: IBufferDecoder, @inject(IDisposableRegistry) private readonly disposableRegistry: IDisposableRegistry) {}
     public create(): Promise<IProcessService> {
-        const processService = new ProcessService(this.serviceContainer.get<IBufferDecoder>(IBufferDecoder), process.env);
-        this.serviceContainer.get<IDisposableRegistry>(IDisposableRegistry).push(processService);
+        const processService = new ProcessService(this.decoder, process.env);
+        this.disposableRegistry.push(processService);
         return Promise.resolve(processService);
     }
 }
diff --git a/src/test/common/process/processFactory.unit.test.ts b/src/test/common/process/processFactory.unit.test.ts
new file mode 100644
index 000000000000..12a64f00c9b3
--- /dev/null
+++ b/src/test/common/process/processFactory.unit.test.ts
@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+'use strict';
+import { expect } from 'chai';
+import { instance, mock, verify, when } from 'ts-mockito';
+import { Disposable, Uri } from 'vscode';
+
+import { BufferDecoder } from '../../../client/common/process/decoder';
+import { ProcessLogger } from '../../../client/common/process/logger';
+import { ProcessService } from '../../../client/common/process/proc';
+import { ProcessServiceFactory } from '../../../client/common/process/processFactory';
+import { IBufferDecoder, IProcessLogger } from '../../../client/common/process/types';
+import { IDisposableRegistry } from '../../../client/common/types';
+import { EnvironmentVariablesProvider } from '../../../client/common/variables/environmentVariablesProvider';
+import { IEnvironmentVariablesProvider } from '../../../client/common/variables/types';
+
+suite('Process - ProcessServiceFactory', () => {
+    let factory: ProcessServiceFactory;
+    let envVariablesProvider: IEnvironmentVariablesProvider;
+    let bufferDecoder: IBufferDecoder;
+    let processLogger: IProcessLogger;
+    let processService: ProcessService;
+    let disposableRegistry: IDisposableRegistry;
+
+    setup(() => {
+        bufferDecoder = mock(BufferDecoder);
+        envVariablesProvider = mock(EnvironmentVariablesProvider);
+        processLogger = mock(ProcessLogger);
+        when(processLogger.logProcess('', [], {})).thenReturn();
+        processService = mock(ProcessService);
+        when(
+            processService.on('exec', () => {
+                return;
+            })
+        ).thenReturn(processService);
+        disposableRegistry = [];
+        factory = new ProcessServiceFactory(instance(envVariablesProvider), instance(processLogger), instance(bufferDecoder), disposableRegistry);
+    });
+
+    teardown(() => {
+        (disposableRegistry as Disposable[]).forEach(d => d.dispose());
+    });
+
+    [Uri.parse('test'), undefined].forEach(resource => {
+        test(`Ensure ProcessService is created with an ${resource ? 'existing' : 'undefined'} resource`, async () => {
+            when(envVariablesProvider.getEnvironmentVariables(resource)).thenResolve({ x: 'test' });
+
+            const proc = await factory.create(resource);
+            verify(envVariablesProvider.getEnvironmentVariables(resource)).once();
+
+            const disposables = disposableRegistry as Disposable[];
+            expect(disposables.length).equal(1);
+            expect(proc).instanceOf(ProcessService);
+        });
+    });
+});
diff --git a/src/test/linters/lint.functional.test.ts b/src/test/linters/lint.functional.test.ts
index b9ad0985514c..f2dc06456ad7 100644
--- a/src/test/linters/lint.functional.test.ts
+++ b/src/test/linters/lint.functional.test.ts
@@ -233,12 +233,10 @@ class TestFixture extends BaseTestFixture {
         configService: IConfigurationService
     ): IPythonExecutionFactory {
         const envVarsService = TypeMoq.Mock.ofType<IEnvironmentVariablesProvider>(undefined, TypeMoq.MockBehavior.Strict);
-        envVarsService.setup(e => e.getEnvironmentVariables(TypeMoq.It.isAny()))
-            .returns(() => Promise.resolve({}));
-        serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IEnvironmentVariablesProvider), TypeMoq.It.isAny()))
-            .returns(() => envVarsService.object);
-        serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IDisposableRegistry), TypeMoq.It.isAny()))
-            .returns(() => []);
+        envVarsService.setup(e => e.getEnvironmentVariables(TypeMoq.It.isAny())).returns(() => Promise.resolve({}));
+        serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IEnvironmentVariablesProvider), TypeMoq.It.isAny())).returns(() => envVarsService.object);
+        const disposableRegistry: IDisposableRegistry = [];
+        serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IDisposableRegistry), TypeMoq.It.isAny())).returns(() => disposableRegistry);
 
         const envActivationService = TypeMoq.Mock.ofType<IEnvironmentActivationService>(undefined, TypeMoq.MockBehavior.Strict);
 
@@ -246,7 +244,13 @@ class TestFixture extends BaseTestFixture {
         serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IBufferDecoder), TypeMoq.It.isAny()))
             .returns(() => decoder);
 
-        const procServiceFactory = new ProcessServiceFactory(serviceContainer.object);
+        const processLogger = TypeMoq.Mock.ofType<IProcessLogger>(undefined, TypeMoq.MockBehavior.Strict);
+        processLogger
+            .setup(p => p.logProcess(TypeMoq.It.isAnyString(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(() => {
+                return;
+            });
+        const procServiceFactory = new ProcessServiceFactory(envVarsService.object, processLogger.object, decoder, disposableRegistry);
 
         return new PythonExecutionFactory(
             serviceContainer.object,