mirror of
https://github.com/ckaczor/azuredatastudio.git
synced 2026-01-27 01:25:36 -05:00
233 lines
9.3 KiB
TypeScript
233 lines
9.3 KiB
TypeScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the Source EULA. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
|
|
import * as azdata from 'azdata';
|
|
import * as vscode from 'vscode';
|
|
import { ApiWrapper } from '../../common/apiWrapper';
|
|
import * as TypeMoq from 'typemoq';
|
|
import * as should from 'should';
|
|
import { AzureModelRegistryService } from '../../modelManagement/azureModelRegistryService';
|
|
import { Config } from '../../configurations/config';
|
|
import { HttpClient } from '../../common/httpClient';
|
|
import { azureResource } from '../../typings/azure-resource';
|
|
|
|
import * as utils from '../utils';
|
|
import { Workspace, WorkspacesListByResourceGroupResponse } from '@azure/arm-machinelearningservices/esm/models';
|
|
import { WorkspaceModel, AssetsQueryByIdResponse, Asset, GetArtifactContentInformation2Response } from '../../modelManagement/interfaces';
|
|
import { AzureMachineLearningWorkspaces, Workspaces } from '@azure/arm-machinelearningservices';
|
|
import { WorkspaceModels } from '../../modelManagement/workspacesModels';
|
|
|
|
interface TestContext {
|
|
|
|
apiWrapper: TypeMoq.IMock<ApiWrapper>;
|
|
config: TypeMoq.IMock<Config>;
|
|
httpClient: TypeMoq.IMock<HttpClient>;
|
|
outputChannel: vscode.OutputChannel;
|
|
op: azdata.BackgroundOperation;
|
|
accounts: azdata.Account[];
|
|
subscriptions: azureResource.AzureResourceSubscription[];
|
|
groups: azureResource.AzureResourceResourceGroup[];
|
|
workspaces: Workspace[];
|
|
models: WorkspaceModel[];
|
|
client: TypeMoq.IMock<AzureMachineLearningWorkspaces>;
|
|
workspacesClient: TypeMoq.IMock<Workspaces>;
|
|
modelClient: TypeMoq.IMock<WorkspaceModels>;
|
|
}
|
|
|
|
function createContext(): TestContext {
|
|
const context = utils.createContext();
|
|
const workspaces = TypeMoq.Mock.ofType(Workspaces);
|
|
const credentials = {
|
|
signRequest: () => {
|
|
return Promise.resolve(undefined!!);
|
|
}
|
|
};
|
|
const client = TypeMoq.Mock.ofInstance(new AzureMachineLearningWorkspaces(credentials, 'subscription'));
|
|
client.setup(x => x.apiVersion).returns(() => '20180101');
|
|
|
|
return {
|
|
apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
|
|
config: TypeMoq.Mock.ofType(Config),
|
|
httpClient: TypeMoq.Mock.ofType(HttpClient),
|
|
outputChannel: context.outputChannel,
|
|
op: context.op,
|
|
accounts: [
|
|
{
|
|
key: {
|
|
providerId: '',
|
|
accountId: 'a1'
|
|
},
|
|
displayInfo: {
|
|
contextualDisplayName: '',
|
|
accountType: '',
|
|
displayName: 'a1',
|
|
userId: 'a1'
|
|
},
|
|
properties:
|
|
{
|
|
tenants: [
|
|
{
|
|
id: '1',
|
|
}
|
|
]
|
|
}
|
|
,
|
|
isStale: true
|
|
}
|
|
],
|
|
subscriptions: [
|
|
{
|
|
name: 's1',
|
|
id: 's1'
|
|
}
|
|
],
|
|
groups: [
|
|
{
|
|
name: 'g1',
|
|
id: 'g1'
|
|
}
|
|
],
|
|
workspaces: [{
|
|
name: 'w1',
|
|
id: 'w1'
|
|
}
|
|
],
|
|
models: [
|
|
{
|
|
name: 'm1',
|
|
id: 'm1',
|
|
url: 'aml://asset/test.test'
|
|
}
|
|
],
|
|
client: client,
|
|
workspacesClient: workspaces,
|
|
modelClient: TypeMoq.Mock.ofInstance(new WorkspaceModels(client.object))
|
|
};
|
|
}
|
|
|
|
describe('AzureModelRegistryService', () => {
|
|
it('getAccounts should return the list of accounts successfully', async function (): Promise<void> {
|
|
let testContext = createContext();
|
|
const accounts = testContext.accounts;
|
|
let service = new AzureModelRegistryService(
|
|
testContext.apiWrapper.object,
|
|
testContext.config.object,
|
|
testContext.httpClient.object,
|
|
testContext.outputChannel);
|
|
testContext.apiWrapper.setup(x => x.getAllAccounts()).returns(() => Promise.resolve(accounts));
|
|
let actual = await service.getAccounts();
|
|
should.deepEqual(actual, testContext.accounts);
|
|
});
|
|
|
|
it('getSubscriptions should return the list of subscriptions successfully', async function (): Promise<void> {
|
|
let testContext = createContext();
|
|
const expected = testContext.subscriptions;
|
|
let service = new AzureModelRegistryService(
|
|
testContext.apiWrapper.object,
|
|
testContext.config.object,
|
|
testContext.httpClient.object,
|
|
testContext.outputChannel);
|
|
testContext.apiWrapper.setup(x => x.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve({ subscriptions: expected, errors: [] }));
|
|
let actual = await service.getSubscriptions(testContext.accounts[0]);
|
|
should.deepEqual(actual, expected);
|
|
});
|
|
|
|
it('getGroups should return the list of groups successfully', async function (): Promise<void> {
|
|
let testContext = createContext();
|
|
const expected = testContext.groups;
|
|
let service = new AzureModelRegistryService(
|
|
testContext.apiWrapper.object,
|
|
testContext.config.object,
|
|
testContext.httpClient.object,
|
|
testContext.outputChannel);
|
|
testContext.apiWrapper.setup(x => x.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve({ resourceGroups: expected, errors: [] }));
|
|
let actual = await service.getGroups(testContext.accounts[0], testContext.subscriptions[0]);
|
|
should.deepEqual(actual, expected);
|
|
});
|
|
|
|
it('getWorkspaces should return the list of workspaces successfully', async function (): Promise<void> {
|
|
let testContext = createContext();
|
|
const response: WorkspacesListByResourceGroupResponse = Object.assign(new Array<Workspace>(...testContext.workspaces), {
|
|
_response: undefined!
|
|
});
|
|
const expected = testContext.workspaces;
|
|
testContext.workspacesClient.setup(x => x.listByResourceGroup(TypeMoq.It.isAny())).returns(() => Promise.resolve(response));
|
|
testContext.workspacesClient.setup(x => x.listBySubscription()).returns(() => Promise.resolve(response));
|
|
testContext.client.setup(x => x.workspaces).returns(() => testContext.workspacesClient.object);
|
|
let service = new AzureModelRegistryService(
|
|
testContext.apiWrapper.object,
|
|
testContext.config.object,
|
|
testContext.httpClient.object,
|
|
testContext.outputChannel);
|
|
|
|
|
|
service.AzureMachineLearningClient = testContext.client.object;
|
|
let actual = await service.getWorkspaces(testContext.accounts[0], testContext.subscriptions[0], testContext.groups[0]);
|
|
should.deepEqual(actual, expected);
|
|
});
|
|
|
|
it('getModels should return the list of models successfully', async function (): Promise<void> {
|
|
let testContext = createContext();
|
|
testContext.config.setup(x => x.amlApiVersion).returns(() => '2018');
|
|
testContext.config.setup(x => x.amlModelManagementUrl).returns(() => 'test.url');
|
|
const expected = testContext.models;
|
|
let service = new AzureModelRegistryService(
|
|
testContext.apiWrapper.object,
|
|
testContext.config.object,
|
|
testContext.httpClient.object,
|
|
testContext.outputChannel);
|
|
service.AzureMachineLearningClient = testContext.client.object;
|
|
service.ModelClient = testContext.modelClient.object;
|
|
testContext.modelClient.setup(x => x.listModels(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(testContext.models));
|
|
let actual = await service.getModels(testContext.accounts[0], testContext.subscriptions[0], testContext.groups[0], testContext.workspaces[0]);
|
|
should.deepEqual(actual, expected);
|
|
});
|
|
|
|
it('downloadModel should download model artifact successfully', async function (): Promise<void> {
|
|
let testContext = createContext();
|
|
const asset: Asset =
|
|
{
|
|
id: '1',
|
|
name: 'asset',
|
|
artifacts: [
|
|
{
|
|
id: '/1/2/3/4/5/'
|
|
}
|
|
]
|
|
};
|
|
const assetResponse: AssetsQueryByIdResponse = Object.assign(asset, {
|
|
_response: undefined!
|
|
});
|
|
const artifactResponse: GetArtifactContentInformation2Response = Object.assign({
|
|
contentUri: 'downloadUrl'
|
|
}, {
|
|
_response: undefined!
|
|
});
|
|
|
|
testContext.config.setup(x => x.amlApiVersion).returns(() => '2018');
|
|
testContext.config.setup(x => x.amlModelManagementUrl).returns(() => 'test.url');
|
|
testContext.config.setup(x => x.amlExperienceUrl).returns(() => 'test.url');
|
|
testContext.client.setup(x => x.sendOperationRequest(TypeMoq.It.isAny(),
|
|
TypeMoq.It.is(p => p.path !== undefined && p.path.startsWith('modelmanagement')), TypeMoq.It.isAny())).returns(() => Promise.resolve(assetResponse));
|
|
testContext.client.setup(x => x.sendOperationRequest(TypeMoq.It.isAny(),
|
|
TypeMoq.It.is(p => p.path !== undefined && p.path.startsWith('artifact')), TypeMoq.It.isAny())).returns(() => Promise.resolve(artifactResponse));
|
|
testContext.apiWrapper.setup(x => x.startBackgroundOperation(TypeMoq.It.isAny())).returns((operationInfo: azdata.BackgroundOperationInfo) => {
|
|
operationInfo.operation(testContext.op);
|
|
});
|
|
testContext.httpClient.setup(x => x.download(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve());
|
|
let service = new AzureModelRegistryService(
|
|
testContext.apiWrapper.object,
|
|
testContext.config.object,
|
|
testContext.httpClient.object,
|
|
testContext.outputChannel);
|
|
service.AzureMachineLearningClient = testContext.client.object;
|
|
service.ModelClient = testContext.modelClient.object;
|
|
testContext.modelClient.setup(x => x.listModels(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(testContext.models));
|
|
let actual = await service.downloadModel(testContext.accounts[0], testContext.subscriptions[0], testContext.groups[0], testContext.workspaces[0], testContext.models[0]);
|
|
should.notEqual(actual, undefined);
|
|
testContext.httpClient.verify(x => x.download(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
|
|
});
|
|
});
|