test('addActiveConnection should add same connection exactly once', (done) => {
		// setup memento for MRU to return a list we have access to
		credentialStore.setup(x => x.saveCredential(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
			.returns(() => Promise.resolve(true));

		// Given we save the same connection twice
		// Then expect the only 1 instance of that connection to be listed in the MRU
		let connectionStore = new ConnectionStore(storageServiceMock.object, context.object, undefined, workspaceConfigurationServiceMock.object,
			credentialStore.object, capabilitiesService, connectionConfig.object);
		connectionStore.clearActiveConnections();
		connectionStore.clearRecentlyUsed();
		let promise = Promise.resolve();
		let cred = Object.assign({}, defaultNamedProfile, { serverName: defaultNamedProfile.serverName + 1 });
		let connectionProfile = new ConnectionProfile(capabilitiesService, cred);
		promise = promise.then(() => {
			return connectionStore.addActiveConnection(defaultNamedConnectionProfile);
		}).then(() => {
			return connectionStore.addActiveConnection(connectionProfile);
		}).then(() => {
			return connectionStore.addActiveConnection(connectionProfile);
		}).then(() => {
			let current = connectionStore.getRecentlyUsedConnections();
			assert.equal(current.length, 2, 'expect 2 unique credentials to have been added');
			assert.equal(current[0].serverName, cred.serverName, 'Expect most recently saved item to be first in list');
			assert.ok(!current[0].password);
		}).then(() => done(), err => done(err));
	});

	test('isPasswordRequired should return false if the password is not required in capabilities', () => {
		let providerName: string = 'providername';
		let connectionProvider: sqlops.ConnectionProviderOptions = {
			options: msSQLCapabilities.connectionProvider.options.map(o => {
				if (o.name === 'password') {
					o.isRequired = false;
				}
				return o;
			})
		};
		let providerCapabilities = {
			protocolVersion: '1',
			providerName: providerName,
			providerDisplayName: providerName,
			connectionProvider: connectionProvider,
			adminServicesProvider: undefined,
			features: undefined
		};

		capabilitiesService.capabilities[providerName] = providerCapabilities;

		let connectionStore = new ConnectionStore(storageServiceMock.object, context.object, undefined, workspaceConfigurationServiceMock.object,
			credentialStore.object, capabilitiesService, connectionConfig.object);
		let connectionProfile: IConnectionProfile = Object.assign({}, defaultNamedProfile, { providerName: providerName });
		let expected: boolean = false;
		let actual = connectionStore.isPasswordRequired(connectionProfile);

		assert.equal(expected, actual);
	});

		}).then(() => {
			let current = connectionStore.getRecentlyUsedConnections();
			// Then verify that since its password based we save the password
			credentialStore.verify(x => x.saveCredential(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
			assert.strictEqual(capturedCreds.password, defaultNamedProfile.password);
			let credId: string = capturedCreds.credentialId;
			assert.ok(credId.includes(ConnectionStore.CRED_PROFILE_USER), 'Expect credential to be marked as an Profile cred');
			assert.ok(!current[0].password);
		}).then(() => {