metaapi.cloud-copyfactory-sdk
Version:
Javascript SDK for SDK for CopyFactory trade copying API. Can copy trades both between MetaTrader 5 (MT5) and MetaTrader 4 (MT4). (https://metaapi.cloud)
1,068 lines (993 loc) • 35.3 kB
text/typescript
'use strict';
import sinon from 'sinon';
import DomainClient from '../domain.client';
import HttpClient from '../httpClient';
import ConfigurationClient, {ClassicPaginationList, NewWebhook, Webhook, WebhookUpdate} from './configuration.client';
import 'should';
/**
* @test {ConfigurationClient}
*/
// eslint-disable-next-line max-statements
describe('ConfigurationClient', () => {
let sandbox;
let copyFactoryClient: ConfigurationClient;
const token = 'header.payload.sign';
let httpClient = new HttpClient();
let domainClient;
let requestStub;
before(() => {
sandbox = sinon.createSandbox();
});
beforeEach(() => {
domainClient = new DomainClient(httpClient, token);
copyFactoryClient = new ConfigurationClient(domainClient);
requestStub = sandbox.stub(domainClient, 'requestCopyFactory');
});
afterEach(() => {
sandbox.restore();
});
/**
* @test {ConfigurationClient#generateAccountId}
*/
it('should generate account id', async () => {
copyFactoryClient.generateAccountId().length.should.equal(64);
});
/**
* @test {ConfigurationClient#generateStrategyId}
*/
it('should generate strategy id', async () => {
let expected = {
id: 'ABCD'
};
requestStub.resolves(expected);
let id = await copyFactoryClient.generateStrategyId();
id.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/unused-strategy-id',
method: 'GET',
headers: {
'auth-token': token
},
json: true,
});
});
/**
* @test {ConfigurationClient#generateStrategyId}
*/
it('should not generate strategy id with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.generateStrategyId();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke generateStrategyId method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#getStrategiesWithInfiniteScrollPagination}
*/
describe('getStrategiesWithInfiniteScrollPagination', () => {
/**
* @test {ConfigurationClient#getStrategiesWithInfiniteScrollPagination}
*/
it('should retrieve strategies from API', async () => {
let expected = [{
_id: 'ABCD',
platformCommissionRate: 0.01,
name: 'Test strategy',
accountId: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
maxTradeRisk: 0.1,
riskLimits: [{
type: 'monthly',
applyTo: 'balance',
maxRelativeRisk: 0.5,
closePositions: false,
startTime: '2020-08-24T00:00:01.000Z'
}],
timeSettings: {
lifetimeInHours: 192,
openingIntervalInMinutes: 5
}
}];
requestStub.resolves(expected);
let strategies = await copyFactoryClient.getStrategiesWithInfiniteScrollPagination({
includeRemoved: true, limit: 100, offset: 200
});
strategies.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies',
method: 'GET',
headers: {
'auth-token': token,
'api-version': '1'
},
params: {
includeRemoved: true,
limit: 100,
offset: 200
},
json: true,
}, true);
});
/**
* @test {ConfigurationClient#getStrategiesWithInfiniteScrollPagination}
*/
it('should not retrieve strategies from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getStrategiesWithInfiniteScrollPagination();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getStrategies method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
});
/**
* @test {ConfigurationClient#getStrategiesWithClassicPagination}
*/
describe('getStrategiesWithClassicPagination', () => {
/**
* @test {ConfigurationClient#getStrategiesWithClassicPagination}
*/
it('should retrieve strategies from API', async () => {
let expected = {
count: 1,
items: [{
_id: 'ABCD',
platformCommissionRate: 0.01,
name: 'Test strategy',
accountId: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
maxTradeRisk: 0.1,
riskLimits: [{
type: 'monthly',
applyTo: 'balance',
maxRelativeRisk: 0.5,
closePositions: false,
startTime: '2020-08-24T00:00:01.000Z'
}],
timeSettings: {
lifetimeInHours: 192,
openingIntervalInMinutes: 5
}
}]
};
requestStub.resolves(expected);
let strategies = await copyFactoryClient.getStrategiesWithClassicPagination({
includeRemoved: true, limit: 100, offset: 200
});
strategies.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies',
method: 'GET',
headers: {
'auth-token': token,
'api-version': '2'
},
params: {
includeRemoved: true,
limit: 100,
offset: 200
},
json: true,
}, true);
});
/**
* @test {ConfigurationClient#getStrategiesWithClassicPagination}
*/
it('should not retrieve strategies from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getStrategiesWithClassicPagination();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getStrategies method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
});
/**
* @test {ConfigurationClient#getStrategy}
*/
it('should retrieve strategy from API', async () => {
let expected = {
_id: 'ABCD',
accountId: 'providerId',
platformCommissionRate: 0.01,
name: 'Test strategy',
connectionId: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
maxTradeRisk: 0.1,
timeSettings: {
lifetimeInHours: 192,
openingIntervalInMinutes: 5
}
};
requestStub.resolves(expected);
let strategies = await copyFactoryClient.getStrategy('ABCD');
strategies.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/ABCD',
method: 'GET',
headers: {
'auth-token': token
},
json: true,
});
});
/**
* @test {ConfigurationClient#getStrategy}
*/
it('should not retrieve strategy from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getStrategy('ABCD');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getStrategy method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#updateStrategy}
*/
it('should update strategy via API', async () => {
const strategy: any = {
name: 'Test strategy',
accountId: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
maxTradeRisk: 0.1,
riskLimits: [{
type: 'monthly',
applyTo: 'balance',
maxRelativeRisk: 0.5,
closePositions: false,
startTime: '2020-08-24T00:00:01.000Z'
}],
timeSettings: {
lifetimeInHours: 192,
openingIntervalInMinutes: 5
}
};
await copyFactoryClient.updateStrategy('ABCD', strategy);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/ABCD',
method: 'PUT',
headers: {
'auth-token': token
},
json: true,
data: strategy});
});
/**
* @test {ConfigurationClient#updateStrategy}
*/
it('should not update strategy via API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.updateStrategy('ABCD', {} as any);
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke updateStrategy method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#removeStrategy}
*/
it('should remove strategy via API', async () => {
const payload: any = {mode: 'preserve', removeAfter: '2020-08-24T00:00:00.000Z'};
await copyFactoryClient.removeStrategy('ABCD', payload);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/ABCD',
method: 'DELETE',
headers: {
'auth-token': token
},
data: payload,
json: true,
});
});
/**
* @test {ConfigurationClient#removeStrategy}
*/
it('should not remove strategy from via with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.removeStrategy('ABCD');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke removeStrategy method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#getPortfolioStrategiesWithInfiniteScrollPagination}
*/
describe('getPortfolioStrategiesWithInfiniteScrollPagination', () => {
/**
* @test {ConfigurationClient#getPortfolioStrategiesWithInfiniteScrollPagination}
*/
it('should retrieve portfolio strategies from API', async () => {
let expected = [{
_id: 'ABCD',
providerId: 'providerId',
platformCommissionRate: 0.01,
name: 'Test strategy',
members: [{strategyId: 'BCDE'}],
maxTradeRisk: 0.1
}];
requestStub.resolves(expected);
let strategies = await copyFactoryClient.getPortfolioStrategiesWithInfiniteScrollPagination({
includeRemoved: true,
limit: 100,
offset: 200
});
strategies.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/portfolio-strategies',
method: 'GET',
headers: {
'auth-token': token,
'api-version': '1'
},
params: {
includeRemoved: true,
limit: 100,
offset: 200
},
json: true
}, true);
});
/**
* @test {ConfigurationClient#getPortfolioStrategiesWithInfiniteScrollPagination}
*/
it('should not retrieve portfolio strategies from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getPortfolioStrategiesWithInfiniteScrollPagination();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getPortfolioStrategies method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
});
/**
* @test {ConfigurationClient#getPortfolioStrategiesWithClassicPagination}
*/
describe('getPortfolioStrategiesWithClassicPagination', () => {
/**
* @test {ConfigurationClient#getPortfolioStrategiesWithClassicPagination}
*/
it('should retrieve portfolio strategies from API', async () => {
let expected = {
count: 1,
items: [{
_id: 'ABCD',
providerId: 'providerId',
platformCommissionRate: 0.01,
name: 'Test strategy',
members: [{strategyId: 'BCDE'}],
maxTradeRisk: 0.1
}]
};
requestStub.resolves(expected);
let strategies = await copyFactoryClient.getPortfolioStrategiesWithClassicPagination({
includeRemoved: true,
limit: 100,
offset: 200
});
strategies.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/portfolio-strategies',
method: 'GET',
headers: {
'auth-token': token,
'api-version': '2'
},
params: {
includeRemoved: true,
limit: 100,
offset: 200
},
json: true
}, true);
});
/**
* @test {ConfigurationClient#getPortfolioStrategiesWithClassicPagination}
*/
it('should not retrieve portfolio strategies from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getPortfolioStrategiesWithClassicPagination();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getPortfolioStrategies method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
});
/**
* @test {ConfigurationClient#getPortfolioStrategy}
*/
it('should retrieve portfolio strategy from API', async () => {
let expected = {
_id: 'ABCD',
providerId: 'providerId',
platformCommissionRate: 0.01,
name: 'Test strategy',
members: [
{
strategyId: 'BCDE'
}
],
maxTradeRisk: 0.1
};
requestStub.resolves(expected);
let strategies = await copyFactoryClient.getPortfolioStrategy('ABCD');
strategies.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/portfolio-strategies/ABCD',
method: 'GET',
headers: {
'auth-token': token
},
json: true,
});
});
/**
* @test {ConfigurationClient#getPortfolioStrategy}
*/
it('should not retrieve portfolio strategy from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getPortfolioStrategy('ABCD');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getPortfolioStrategy method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#updatePortfolioStrategy}
*/
it('should update portfolio strategy via API', async () => {
const strategy: any = {
name: 'Test strategy',
members: [
{
strategyId: 'BCDE'
}
],
maxTradeRisk: 0.1
};
await copyFactoryClient.updatePortfolioStrategy('ABCD', strategy);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/portfolio-strategies/ABCD',
method: 'PUT',
headers: {
'auth-token': token
},
json: true,
data: strategy
});
});
/**
* @test {ConfigurationClient#updatePortfolioStrategy}
*/
it('should not update portfolio strategy via API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.updatePortfolioStrategy('ABCD', {} as any);
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke updatePortfolioStrategy method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#removePortfolioStrategy}
*/
it('should remove portfolio strategy via API', async () => {
const payload: any = {mode: 'preserve', removeAfter: '2020-08-24T00:00:00.000Z'};
await copyFactoryClient.removePortfolioStrategy('ABCD', payload);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/portfolio-strategies/ABCD',
method: 'DELETE',
headers: {
'auth-token': token
},
data: payload,
json: true,
});
});
/**
* @test {ConfigurationClient#removePortfolioStrategy}
*/
it('should not remove portfolio strategy from via with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.removePortfolioStrategy('ABCD');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke removePortfolioStrategy method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#removePortfolioStrategyMember}
*/
it('should remove portfolio strategy member via API', async () => {
const payload: any = {mode: 'preserve', removeAfter: '2020-08-24T00:00:00.000Z'};
await copyFactoryClient.removePortfolioStrategyMember('ABCD', 'BCDE', payload);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/portfolio-strategies/ABCD/members/BCDE',
method: 'DELETE',
headers: {
'auth-token': token
},
data: payload,
json: true,
});
});
/**
* @test {ConfigurationClient#removePortfolioStrategyMember}
*/
it('should not remove portfolio strategy member from via with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.removePortfolioStrategyMember('ABCD', 'BCDE');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke removePortfolioStrategyMember method, because you have connected with account access ' +
'token. Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#getSubscribersWithInfiniteScrollPagination}
*/
describe('getSubscribersWithInfiniteScrollPagination', () => {
/**
* @test {TradingClient#getSubscribersWithInfiniteScrollPagination}
*/
it('should retrieve CopyFactory subscribers from API', async () => {
let expected = [{
_id: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
name: 'Demo account',
reservedMarginFraction: 0.25,
subscriptions: [{strategyId: 'ABCD', multiplier: 1}]
}];
requestStub.resolves(expected);
let accounts = await copyFactoryClient.getSubscribersWithInfiniteScrollPagination({
includeRemoved: true,
limit: 100,
offset: 200
});
accounts.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/subscribers',
method: 'GET',
headers: {
'auth-token': token,
'api-version': '1'
},
params: {
includeRemoved: true,
limit: 100,
offset: 200
},
json: true
}, true);
});
/**
* @test {TradingClient#getSubscribersWithInfiniteScrollPagination}
*/
it('should not retrieve subscribers from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getSubscribersWithInfiniteScrollPagination();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getSubscribers method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
});
/**
* @test {ConfigurationClient#getSubscribersWithClassicPagination}
*/
describe('getSubscribersWithClassicPagination', () => {
/**
* @test {TradingClient#getSubscribersWithClassicPagination}
*/
it('should retrieve CopyFactory subscribers from API', async () => {
let expected = {
count: 1,
items: [{
_id: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
name: 'Demo account',
reservedMarginFraction: 0.25,
subscriptions: [{strategyId: 'ABCD', multiplier: 1}]
}]
};
requestStub.resolves(expected);
let accounts = await copyFactoryClient.getSubscribersWithClassicPagination({
includeRemoved: true,
limit: 100,
offset: 200
});
accounts.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/subscribers',
method: 'GET',
headers: {
'auth-token': token,
'api-version': '2'
},
params: {
includeRemoved: true,
limit: 100,
offset: 200
},
json: true
}, true);
});
/**
* @test {TradingClient#getSubscribersWithClassicPagination}
*/
it('should not retrieve subscribers from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getSubscribersWithClassicPagination();
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getSubscribers method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
});
/**
* @test {TradingClient#getSubscriber}
*/
it('should retrieve CopyFactory subscriber from API', async () => {
let expected = {
_id: 'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
name: 'Demo account',
reservedMarginFraction: 0.25,
subscriptions: [
{
strategyId: 'ABCD',
multiplier: 1
}
]
};
requestStub.resolves(expected);
let accounts = await copyFactoryClient
.getSubscriber('e8867baa-5ec2-45ae-9930-4d5cea18d0d6');
accounts.should.equal(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/subscribers/' +
'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
method: 'GET',
headers: {
'auth-token': token
},
json: true,
});
});
/**
* @test {TradingClient#getSubscriber}
*/
it('should not retrieve CopyFactory subscriber from API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.getSubscriber('test');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke getSubscriber method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {TradingClient#updateSubscriber}
*/
it('should update CopyFactory subscriber via API', async () => {
let subscriber = {
name: 'Demo account',
reservedMarginFraction: 0.25,
subscriptions: [
{
strategyId: 'ABCD',
multiplier: 1
}
]
};
await copyFactoryClient
.updateSubscriber('e8867baa-5ec2-45ae-9930-4d5cea18d0d6', subscriber);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/subscribers/' +
'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
method: 'PUT',
headers: {
'auth-token': token
},
data: subscriber,
json: true,
});
});
/**
* @test {TradingClient#updateSubscriber}
*/
it('should not update CopyFactory subscriber via API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.updateSubscriber('test', {} as any);
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke updateSubscriber method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {TradingClient#removeSubscriber}
*/
it('should remove CopyFactory subscriber via API', async () => {
const payload: any = {mode: 'preserve', removeAfter: '2020-08-24T00:00:00.000Z'};
await copyFactoryClient
.removeSubscriber('e8867baa-5ec2-45ae-9930-4d5cea18d0d6', payload);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/subscribers/' +
'e8867baa-5ec2-45ae-9930-4d5cea18d0d6',
method: 'DELETE',
headers: {
'auth-token': token
},
data: payload,
json: true,
});
});
/**
* @test {TradingClient#removeSubscriber}
*/
it('should not remove CopyFactory subscriber via API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.removeSubscriber('test');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke removeSubscriber method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {TradingClient#removeSubscription}
*/
it('should remove CopyFactory subscription via API', async () => {
const payload: any = {mode: 'preserve', removeAfter: '2020-08-24T00:00:00.000Z'};
await copyFactoryClient
.removeSubscription('e8867baa-5ec2-45ae-9930-4d5cea18d0d6', 'ABCD', payload);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/subscribers/' +
'e8867baa-5ec2-45ae-9930-4d5cea18d0d6/subscriptions/ABCD',
method: 'DELETE',
headers: {
'auth-token': token
},
data: payload,
json: true,
});
});
/**
* @test {TradingClient#removeSubscription}
*/
it('should not remove CopyFactory subscription via API with account token', async () => {
domainClient = new DomainClient(httpClient, 'token');
copyFactoryClient = new ConfigurationClient(domainClient);
try {
await copyFactoryClient.removeSubscription('test', 'ABCD');
throw new Error('MethodAccessError expected');
} catch (error) {
error.name.should.equal('MethodAccessError');
error.message.should.equal(
'You can not invoke removeSubscription method, because you have connected with account access token. ' +
'Please use API access token from https://app.metaapi.cloud/token page to invoke this method.'
);
}
});
/**
* @test {ConfigurationClient#getWebhooksWithInfiniteScrollPagination}
*/
describe('getWebhooksWithInfiniteScrollPagination', () => {
/**
* @test {TradingClient#getWebhooksWithInfiniteScrollPagination}
*/
it('should retrieve webhooks from API', async () => {
let expected: Webhook[] = [
{_id: 'id1', createdAt: new Date(10), url: 'url1', symbolMapping: [{from: 'symbol1', to: 'symbol2'}]},
{_id: 'id2', createdAt: new Date(100), url: 'url2', symbolMapping: []}
];
requestStub.resolves(JSON.parse(JSON.stringify(expected)));
let actual = await copyFactoryClient.getWebhooksWithInfiniteScrollPagination('strategy1', {
limit: 100,
offset: 200
});
actual.should.deepEqual(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/strategy1/webhooks',
method: 'GET',
headers: {'auth-token': token},
params: {
paginationStyle: 'infiniteScroll',
limit: 100,
offset: 200
},
json: true
}, true);
});
});
/**
* @test {ConfigurationClient#getWebhooksWithClassicPagination}
*/
describe('getWebhooksWithClassicPagination', () => {
/**
* @test {TradingClient#getWebhooksWithClassicPagination}
*/
it('should retrieve webhooks from API', async () => {
let expected: ClassicPaginationList<Webhook> = {
count: 2,
items: [
{_id: 'id1', createdAt: new Date(10), url: 'url1', symbolMapping: [{from: 'symbol1', to: 'symbol2'}]},
{_id: 'id2', createdAt: new Date(100), url: 'url2', symbolMapping: []}
]
};
requestStub.resolves(JSON.parse(JSON.stringify(expected)));
let actual = await copyFactoryClient.getWebhooksWithClassicPagination('strategy1', {
limit: 100,
offset: 200
});
actual.should.deepEqual(expected);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/strategy1/webhooks',
method: 'GET',
headers: {'auth-token': token},
params: {
paginationStyle: 'classic',
limit: 100,
offset: 200
},
json: true
}, true);
});
});
/**
* @test {ConfigurationClient#createWebhook}
*/
describe('createWebhook', () => {
/**
* @test {ConfigurationClient#createWebhook}
*/
it('should create webhook via API', async () => {
const webhook: NewWebhook = {
magic: 100,
symbolMapping: [{from: 'symbol1', to: 'symbol2'}]
};
domainClient.requestCopyFactory.resolves('webhook1');
let actual = await copyFactoryClient.createWebhook('strategy1', webhook);
actual.should.equal('webhook1');
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/strategy1/webhooks',
method: 'POST',
headers: {'auth-token': token},
json: true,
data: webhook
});
});
});
/**
* @test {ConfigurationClient#updateWebhook}
*/
describe('updateWebhook', () => {
/**
* @test {ConfigurationClient#updateWebhook}
*/
it('should update webhook via API', async () => {
const webhook: WebhookUpdate = {
magic: 100,
symbolMapping: [{from: 'symbol1', to: 'symbol2'}]
};
await copyFactoryClient.updateWebhook('strategy1', 'webhook1', webhook);
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/strategy1/webhooks/webhook1',
method: 'PATCH',
headers: {'auth-token': token},
json: true,
data: webhook
});
});
});
/**
* @test {ConfigurationClient#deleteWebhook}
*/
describe('deleteWebhook', () => {
/**
* @test {ConfigurationClient#deleteWebhook}
*/
it('should update webhook via API', async () => {
await copyFactoryClient.deleteWebhook('strategy1', 'webhook1');
sinon.assert.calledOnceWithExactly(domainClient.requestCopyFactory, {
url: '/users/current/configuration/strategies/strategy1/webhooks/webhook1',
method: 'DELETE',
headers: {'auth-token': token},
json: true
});
});
});
});