public async Task EditMetadataBadRequest(string badName)
{
string url = ApiPaths.ALGO_STORE_METADATA;
CreateAlgoDTO metadata = new CreateAlgoDTO()
{
Name = Helpers.RandomString(8),
Description = Helpers.RandomString(8)
};
var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(metadata), Method.POST);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.OK));
AlgoDataDTO responseMetaData = JsonUtils.DeserializeJson <AlgoDataDTO>(response.ResponseJson);
url = ApiPaths.ALGO_STORE_METADATA;
EditAlgoDTO editMetaData = new EditAlgoDTO()
{
Id = responseMetaData.Id,
Name = badName,
Description = badName
};
var responseMetaDataAfterEdit = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responseMetaDataAfterEdit.Status, Is.EqualTo(HttpStatusCode.BadRequest));
}
public async Task <InstanceDataDTO> SaveInstance(AlgoDataDTO algoData, AlgoInstanceType instanceType, bool useExistingWallet = true)
{
if (instanceType == AlgoInstanceType.Live)
{
walletDTO = useExistingWallet == true ? await GetExistingWallet() : await CreateTestWallet();
}
// Build days offset
DaysOffsetDTO daysOffsetDTO = BuildDaysOffsetByInstanceType(instanceType);
// Build InstanceParameters
instanceParameters = InstanceConfig.ValidMetaData;
// Build instance request payload
var instanceForAlgo = InstanceDataBuilder.BuildInstanceData(algoData, walletDTO, instanceType, instanceParameters, daysOffsetDTO);
// Build save instance url
var url = instanceType == AlgoInstanceType.Live ? ApiPaths.ALGO_STORE_SAVE_ALGO_INSTANCE : ApiPaths.ALGO_STORE_FAKE_TRADING_INSTANCE_DATA;
string requestBody = JsonUtils.SerializeObject(instanceForAlgo);
var saveInstanceResponse = await Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, requestBody, Method.POST);
message = $"POST {url} returned status: {saveInstanceResponse.Status} and response: {saveInstanceResponse.ResponseJson}. Expected: {HttpStatusCode.OK}";
Assert.That(saveInstanceResponse.Status, Is.EqualTo(HttpStatusCode.OK), message);
var instanceData = JsonUtils.DeserializeJson <InstanceDataDTO>(saveInstanceResponse.ResponseJson);
// Add Instance to the list so that it can be deleted in the the TearDown
instancesList.Add(instanceData);
return(instanceData);
}
public async Task UploadMetadataWithEmptyDescription()
{
string url = ApiPaths.ALGO_STORE_METADATA;
CreateAlgoDTO metadata = new CreateAlgoDTO()
{
Name = Helpers.RandomString(8),
Description = ""
};
var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(metadata), Method.POST);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.OK));
AlgoDataDTO responseMetaData = JsonUtils.DeserializeJson <AlgoDataDTO>(response.ResponseJson);
Assert.AreEqual(metadata.Name, responseMetaData.Name);
Assert.AreEqual(metadata.Description, responseMetaData.Description);
Assert.NotNull(responseMetaData.DateCreated);
Assert.NotNull(responseMetaData.DateModified);
Assert.NotNull(responseMetaData.Id);
Assert.Null(responseMetaData.AlgoVisibility);
MetaDataEntity metaDataEntity = await MetaDataRepository.TryGetAsync(t => t.Id == responseMetaData.Id) as MetaDataEntity;
Assert.NotNull(metaDataEntity);
Assert.AreEqual(metaDataEntity.Id, responseMetaData.Id);
Assert.AreEqual(metaDataEntity.Name, responseMetaData.Name);
Assert.AreEqual(metaDataEntity.Description, responseMetaData.Description);
}
public async Task CheckTailLogsForStoppedInstances(AlgoInstanceType algoInstanceType)
{
// Create an algo
AlgoDataDTO algoData = await CreateAlgo();
// Create algo instance
var instanceData = await SaveInstance(algoData, algoInstanceType);
// Wait up to 3 minutes for the instance to start
await WaitAlgoInstanceToStart(instanceData.InstanceId);
// Stop the instance
await StopAlgoInstance(instanceData);
//Get the instance
ClientInstanceEntity instanceDataFromDB = await ClientInstanceRepository.TryGetAsync($"algo_{algoData.Id}", instanceData.InstanceId) as ClientInstanceEntity;
Assert.That(instanceDataFromDB.AlgoInstanceStatus, Is.EqualTo(AlgoInstanceStatus.Stopped));
// Wait 30 seconds
Wait.ForPredefinedTime(30 * 1000);
var tailLog = await GetInstanceTailLogFromApi(instanceData);
Assert.That(tailLog, Is.Not.Null);
}
public async Task DeleteMetadataBadRequest(string badID)
{
string url = ApiPaths.ALGO_STORE_METADATA;
CreateAlgoDTO metadata = new CreateAlgoDTO()
{
Name = Helpers.RandomString(8),
Description = Helpers.RandomString(8)
};
var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(metadata), Method.POST);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.OK));
AlgoDataDTO responseMetaData = JsonUtils.DeserializeJson <AlgoDataDTO>(response.ResponseJson);
CascadeDeleteDTO editMetaData = new CascadeDeleteDTO()
{
AlgoId = badID,
InstanceId = responseMetaData.Name
};
url = ApiPaths.ALGO_STORE_CASCADE_DELETE;
var responceCascadeDelete = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responceCascadeDelete.Status, Is.EqualTo(HttpStatusCode.BadRequest));
}
public async Task UpdateUploadedStringAlgo()
{
string url = ApiPaths.ALGO_STORE_METADATA;
CreateAlgoDTO metadata = new CreateAlgoDTO()
{
Name = Helpers.RandomString(13),
Description = Helpers.RandomString(13)
};
var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(metadata), Method.POST);
AlgoDataDTO responseMetaData = JsonUtils.DeserializeJson <AlgoDataDTO>(response.ResponseJson);
url = ApiPaths.ALGO_STORE_UPLOAD_STRING;
UploadStringDTO stringDTO = new UploadStringDTO()
{
AlgoId = responseMetaData.Id,
Data = this.CSharpAlgoString
};
var responsetemp = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(stringDTO), Method.POST);
Assert.True(responsetemp.Status == System.Net.HttpStatusCode.NoContent);
Dictionary <string, string> quaryParamGetString = new Dictionary <string, string>()
{
{ "AlgoId", responseMetaData.Id }
};
var responceGetUploadString = await this.Consumer.ExecuteRequest(url, quaryParamGetString, null, Method.GET);
Assert.That(responceGetUploadString.Status, Is.EqualTo(HttpStatusCode.OK));
UploadStringDTO uploadedStringContent = JsonUtils.DeserializeJson <UploadStringDTO>(responceGetUploadString.ResponseJson);
Assert.That(stringDTO.Data, Is.EqualTo(uploadedStringContent.Data));
UploadStringDTO UpdatedstringDTO = new UploadStringDTO()
{
AlgoId = responseMetaData.Id,
Data = "Updated Text"
};
var responsetempUpdated = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(UpdatedstringDTO), Method.POST);
Assert.True(responsetempUpdated.Status == System.Net.HttpStatusCode.NoContent);
var responceGetUploadStringUpdated = await this.Consumer.ExecuteRequest(url, quaryParamGetString, null, Method.GET);
Assert.That(responceGetUploadStringUpdated.Status, Is.EqualTo(HttpStatusCode.OK));
UploadStringDTO uploadedStringContentUpdated = JsonUtils.DeserializeJson <UploadStringDTO>(responceGetUploadStringUpdated.ResponseJson);
Assert.That(UpdatedstringDTO.Data, Is.EqualTo(uploadedStringContentUpdated.Data));
}
public async Task AssertAlgoNotDeleted(Response deleteAlgoRequest, AlgoDataDTO algoData, string errorMessage)
{
AlgoErrorDTO deleteAlgoResponse = JsonUtils.DeserializeJson <AlgoErrorDTO>(deleteAlgoRequest.ResponseJson);
Assert.That(deleteAlgoRequest.Status, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(deleteAlgoResponse.DisplayMessage, Is.EqualTo(errorMessage));
// Assert algo is not deleted from DB
Assert.That(await AlgoExists(algoData), Is.True);
}
public async Task AssertAlgoDeleted(Response deleteAlgoRequest, AlgoDataDTO algoData)
{
AlgoErrorDTO deleteAlgoResponse = JsonUtils.DeserializeJson <AlgoErrorDTO>(deleteAlgoRequest.ResponseJson);
Assert.That(deleteAlgoRequest.Status, Is.EqualTo(HttpStatusCode.OK));
Assert.That(deleteAlgoResponse, Is.Null);
// Assert algo is deleted from DB
Assert.That(await AlgoExists(algoData), Is.False);
}
public async Task MakeAlgoPrivate(AlgoDataDTO algoData)
{
AddToPublicDTO addAlgo = new AddToPublicDTO()
{
AlgoId = algoData.Id,
ClientId = algoData.ClientId
};
var makeAlgoPrivateResponse = await Consumer.ExecuteRequest(ApiPaths.ALGO_STORE_REMOVE_FROM_PUBLIC, Helpers.EmptyDictionary, JsonUtils.SerializeObject(addAlgo), Method.POST);
Assert.That(makeAlgoPrivateResponse.Status, Is.EqualTo(HttpStatusCode.OK));
}
public static InstanceDataDTO BuildInstanceData(AlgoDataDTO algoData, WalletDTO walletDTO, AlgoInstanceType instanceType, InstanceParameters instanceParameters, DaysOffsetDTO daysOffsetDTO, bool withInvalidAlgoId = false, bool withoutMetadaData = false)
{
AlgoMetaDataInformation algoMetaDataInformation = BuildAlgoMetaDataInformation(instanceParameters, daysOffsetDTO);
if (withInvalidAlgoId)
{
algoData.Id = $"NonExistingAlgoId - {Helpers.GetFullUtcTimestamp()}";
}
return(new InstanceDataDTO(algoData, walletDTO, instanceType, algoMetaDataInformation));
}
public static InstanceDataDTO BuildInstanceData(AlgoDataDTO algoData, WalletDTO walletDTO, AlgoInstanceType instanceType, InstanceParameters instanceParameters, DaysOffsetDTO daysOffsetDTO, string instanceName = null)
{
AlgoMetaDataInformation algoMetaDataInformation = BuildAlgoMetaDataInformation(instanceParameters, daysOffsetDTO);
if (instanceParameters.UseInvalidAlgoId)
{
algoData.Id = $"NonExistingAlgoId - {Helpers.GetFullUtcTimestamp()}";
}
return(new InstanceDataDTO(algoData, walletDTO, instanceType, algoMetaDataInformation, instanceName));
}
public async Task <Response> DeleteAlgo(AlgoDataDTO algoData, bool forceDelete = false)
{
DeleteAlgoDTO deleteAlgoDTO = new DeleteAlgoDTO()
{
AlgoId = algoData.Id,
AlgoClientId = algoData.ClientId,
ForceDelete = forceDelete
};
// Delete the algo
return(await Consumer.ExecuteRequest(ApiPaths.ALGO_STORE_DELETE_ALGO, Helpers.EmptyDictionary, JsonUtils.SerializeObject(deleteAlgoDTO), Method.DELETE));
}
public async Task <InstanceDataDTO> SaveInstance(AlgoDataDTO algoData, AlgoInstanceType instanceType, bool useExistingWallet = true)
{
if (instanceType == AlgoInstanceType.Live)
{
walletDTO = useExistingWallet == true ? await GetExistingWallet() : await CreateTestWallet();
}
// Build days offset
DaysOffsetDTO daysOffsetDTO = BuildDaysOffsetByInstanceType(instanceType);
// Build InstanceParameters
instanceParameters = new InstanceParameters()
{
AssetPair = "BTCUSD",
TradedAsset = "USD",
InstanceTradeVolume = 4,
InstanceCandleInterval = CandleTimeInterval.Minute,
FunctionCandleInterval = CandleTimeInterval.Day,
FunctionCandleOperationMode = CandleOperationMode.CLOSE,
FunctionCapacity = 4,
InstanceFunctions = new List <FunctionType>()
{
FunctionType.SMA_Short, FunctionType.SMA_Long
}
};
// Build instance request payload
var instanceForAlgo = InstanceDataBuilder.BuildInstanceData(algoData, walletDTO, instanceType, instanceParameters, daysOffsetDTO);
// Build save instance url
var url = instanceType == AlgoInstanceType.Live ? ApiPaths.ALGO_STORE_SAVE_ALGO_INSTANCE : ApiPaths.ALGO_STORE_FAKE_TRADING_INSTANCE_DATA;
string requestBody = JsonUtils.SerializeObject(instanceForAlgo);
var saveInstanceResponse = await Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, requestBody, Method.POST);
message = $"POST {url} returned status: {saveInstanceResponse.Status} and response: {saveInstanceResponse.ResponseJson}. Expected: {HttpStatusCode.OK}";
Assert.That(saveInstanceResponse.Status, Is.EqualTo(HttpStatusCode.OK), message);
var instanceData = JsonUtils.DeserializeJson <InstanceDataDTO>(saveInstanceResponse.ResponseJson);
// Add Instance to the list so that it can be deleted in the the TearDown
instancesList.Add(instanceData);
return(instanceData);
}
public async Task CheckDatePublishedOnAlgoVisibilityChange()
{
// Create an algo
AlgoDataDTO algoData = await CreateAlgo();
// Get the test algo
AlgoEntity algo = await AlgoRepository.TryGetAsync(algoData.ClientId, algoData.Id) as AlgoEntity;
Assert.That(algoData.AlgoVisibility, Is.EqualTo(AlgoVisibility.Private));
Assert.That(algoData.DatePublished, Is.Null);
// Build the body for the request
var model = new AddToPublicDTO
{
ClientId = algo.ClientId,
AlgoId = algo.AlgoId
};
// Change algo's visibility to 'public'
var changeAlgoVisibility = await Consumer.ExecuteRequest(ApiPaths.ALGO_STORE_ADD_TO_PUBLIC, Helpers.EmptyDictionary, JsonUtils.SerializeObject(model), Method.POST);
Assert.That(changeAlgoVisibility.Status, Is.EqualTo(HttpStatusCode.OK));
// Get the test algo
algo = await AlgoRepository.TryGetAsync(algoData.ClientId, algoData.Id) as AlgoEntity;
// Check if the algo's visibility is successfully changed and DataPublished is available
Assert.That(algo.AlgoVisibility, Is.EqualTo(AlgoVisibility.Public));
Assert.That(algo.DatePublished.Value, Is.EqualTo(DateTime.UtcNow).Within(3).Minutes);
// Change the current algo's visibility to be 'private'
changeAlgoVisibility = await Consumer.ExecuteRequest(ApiPaths.ALGO_STORE_REMOVE_FROM_PUBLIC, Helpers.EmptyDictionary, JsonUtils.SerializeObject(model), Method.POST);
Assert.That(changeAlgoVisibility.Status, Is.EqualTo(HttpStatusCode.OK));
// Get the test algo with the changes
algo = await AlgoRepository.TryGetAsync(algoData.ClientId, algoData.Id) as AlgoEntity;
//Check if the algo's visibility is 'private' and DatePublished is NULL
Assert.That(algo.AlgoVisibility, Is.EqualTo(AlgoVisibility.Private));
Assert.That(algo.DatePublished, Is.Null);
}
public async Task AttemptToDeleteActiveAlgoInstance(AlgoInstanceType algoInstanceType)
{
// Create an algo
AlgoDataDTO algoData = await CreateAlgo();
// Start an instance
var instanceData = await SaveInstance(algoData, algoInstanceType);
// Build the body for the request
var model = new DeleteAlgoInstanceDTO
{
AlgoId = instanceData.AlgoId,
InstanceId = instanceData.InstanceId,
AlgoClientId = instanceData.AlgoClientId
};
// Send the request
var deleteAlgoInstance = await Consumer.ExecuteRequest(ApiPaths.ALGO_STORE_DELETE_INSTANCE,
Helpers.EmptyDictionary, JsonUtils.SerializeObject(model), Method.DELETE);
Assert.That(deleteAlgoInstance.Status, Is.EqualTo(HttpStatusCode.BadRequest));
// Get instance data from DB
ClientInstanceEntity instanceDataFromDB = await ClientInstanceRepository.TryGetAsync($"algo_{algoData.Id}", instanceData.InstanceId) as ClientInstanceEntity;
Assert.That(instanceDataFromDB, Is.Not.Null);
// Wait up to 3 minutes for the instance to start
await WaitAlgoInstanceToStart(instanceData.InstanceId);
// Send the request
deleteAlgoInstance = await Consumer.ExecuteRequest(ApiPaths.ALGO_STORE_DELETE_INSTANCE,
Helpers.EmptyDictionary, JsonUtils.SerializeObject(model), Method.DELETE);
Assert.That(deleteAlgoInstance.Status, Is.EqualTo(HttpStatusCode.BadRequest));
// Get instance data from DB
instanceDataFromDB = await ClientInstanceRepository.TryGetAsync($"algo_{algoData.Id}", instanceData.InstanceId) as ClientInstanceEntity;
Assert.That(instanceDataFromDB, Is.Not.Null);
}
public InstanceDataDTO(AlgoDataDTO algoData, WalletDTO wallet, AlgoInstanceType algoInstanceType, AlgoMetaDataInformation algoMetaDataInformation, string instanceName = null)
{
AlgoId = algoData.Id;
AlgoClientId = algoData.ClientId;
InstanceName = instanceName ?? $"{algoInstanceType} {Helpers.GetTimestampIso8601()}{GlobalConstants.AutoTest}_IntanceName";
AlgoInstanceType = algoInstanceType;
AlgoMetaDataInformation = algoMetaDataInformation;
if (algoInstanceType == AlgoInstanceType.Live)
{
WalletId = wallet.Id;
FakeTradingTradingAssetBalance = null;
FakeTradingAssetTwoBalance = null;
}
else
{
WalletId = null;
FakeTradingTradingAssetBalance = 8192;
FakeTradingAssetTwoBalance = 2.048;
}
}
// TODO: Add test cases for the other algos as well
public async Task CheckMonitoringService(string whilePosition, string message)
{
// Set algoString
var algoString = File.ReadAllText(String.Format(DummyAlgoWhileLoop, whilePosition));
// Create algo
AlgoDataDTO algoData = await CreateAlgo(algoString);
// Start an instance
var instanceData = await SaveInstance(algoData, AlgoInstanceType.Demo);
// Wait up to 3 minutes for the instance to start
await WaitAlgoInstanceToStart(instanceData.InstanceId);
// Wait for up to 5 minutes so that the algo can be stopped
int maxWaitTime = 5 * 60 * 1000; // 5 minutes
int waitTime = 5 * 1000; // 5 seconds
while (maxWaitTime > 0)
{
Wait.ForPredefinedTime(waitTime);
maxWaitTime -= waitTime;
var instanceStatus = await GetInstanceStatus(instanceData.InstanceId);
if (instanceStatus == AlgoInstanceStatus.Stopped)
{
break;
}
}
// Get instance log
var instanceLog = await GetInstanceTailLogFromLoggingService(postInstanceData);
var instanceMessages = instanceLog.Select(x => x.Message).ToList();
// Assert message added to log
Assert.That(instanceMessages, Does.Contain(message));
}
public async Task CheckTcBuildData(AlgoInstanceType algoInstanceType)
{
// Create an algo
AlgoDataDTO algoData = await CreateAlgo();
// Create an instance
var instanceData = await SaveInstance(algoData, algoInstanceType);
// Wait up to 3 minutes for the instance to start
await WaitAlgoInstanceToStart(instanceData.InstanceId);
// Get the Instance
ClientInstanceEntity instanceDataFromDB = await ClientInstanceRepository.TryGetAsync($"algo_{algoData.Id}", instanceData.InstanceId) as ClientInstanceEntity;
Assert.That(instanceDataFromDB, Is.Not.Null);
// Get TcBuild log
TcBuildEntity tcBuildDataFromDB = await TcBuildRepository.TryGetAsync("TcBuildEntity", instanceDataFromDB.TcBuildId) as TcBuildEntity;
Assert.That(tcBuildDataFromDB.InstanceId, Is.EqualTo(instanceDataFromDB.Id));
Assert.That(tcBuildDataFromDB.ClientId, Is.EqualTo(instanceDataFromDB.ClientId));
Assert.That(tcBuildDataFromDB.TcBuildId, Is.EqualTo(instanceDataFromDB.TcBuildId));
}
public async Task CheckHistoryCandles(AlgoInstanceType algoInstanceType)
{
int daysBack = -2;
// Create an algo
AlgoDataDTO algoData = await CreateAlgo();
// Start an instance
var instanceData = await SaveInstance(algoData, algoInstanceType);
// Wait up to 3 minutes for the instance to start
await WaitAlgoInstanceToStart(instanceData.InstanceId);
// Build History Api candles url
var historyApiCandlesUrl = $"{BaseUrl.AlgoStoreHistoryApiBaseUrl}{ApiPaths.ALGO_STORE_HISTORY_API_CANDLES}";
// Build params dictionary
Dictionary <string, string> historyApiCandlesRequestParams = new Dictionary <string, string>
{
{ "StartFrom", InstanceDataBuilder.FunctionsDictionary[FunctionType.SMA_Short.ToString()].StartingDate.ToString(GlobalConstants.ISO_8601_DATE_FORMAT) },
{ "EndOn", InstanceDataBuilder.FunctionsDictionary[FunctionType.SMA_Long.ToString()].EndingDate.AddDays(daysBack).ToString(GlobalConstants.ISO_8601_DATE_FORMAT) },
{ "IndicatorName", FunctionType.SMA_Short.ToString() }
};
// Get instance data from DB
ClientInstanceEntity instanceDataFromDB = await ClientInstanceRepository.TryGetAsync(t => t.Id == instanceData.InstanceId) as ClientInstanceEntity;
// Get instance history candles
var histiryApiCandles = await Consumer.ExecuteRequestCustomEndpoint(historyApiCandlesUrl, historyApiCandlesRequestParams, null, Method.GET, instanceDataFromDB.AuthToken);
Assert.That(histiryApiCandles.Status, Is.EqualTo(HttpStatusCode.OK));
List <CandleDTO> actualResult = JsonUtils.DeserializeJson <List <CandleDTO> >(histiryApiCandles.ResponseJson);
// Build Api v2 candles url
var apiV2CandlesUrl = $"{BaseUrl.ApiV2BaseUrl}{ApiPaths.API_V2_CANDLES_HISTORY}";
// Build params dictionary
Dictionary <string, string> apiV2CandlesRequestParams = new Dictionary <string, string>
{
{ "Type", "Spot" },
{ "PriceType", "Mid" },
{ "AssetPairId", InstanceDataBuilder.FunctionsDictionary[FunctionType.SMA_Short.ToString()].AssetPair },
{ "TimeInterval", InstanceDataBuilder.FunctionsDictionary[FunctionType.SMA_Short.ToString()].CandleTimeInterval.ToString() },
{ "FromMoment", InstanceDataBuilder.FunctionsDictionary[FunctionType.SMA_Long.ToString()].StartingDate.ToString(GlobalConstants.ISO_8601_DATE_FORMAT) },
{ "ToMoment", InstanceDataBuilder.FunctionsDictionary[FunctionType.SMA_Long.ToString()].EndingDate.AddDays(daysBack).ToString(GlobalConstants.ISO_8601_DATE_FORMAT) }
};
// Get expected history candles
var apiV2Candles = await Consumer.ExecuteRequestCustomEndpoint(apiV2CandlesUrl, apiV2CandlesRequestParams, null, Method.GET);
Assert.That(apiV2Candles.Status, Is.EqualTo(HttpStatusCode.OK));
ApiV2HistoryCandles apiV2HistoryCandles = JsonUtils.DeserializeJson <ApiV2HistoryCandles>(apiV2Candles.ResponseJson);
// Get expected result
List <CandleDTO> expectedResult = apiV2HistoryCandles.History.Select(c => new CandleDTO()
{
DateTime = c.DateTime,
Open = c.Open,
Close = c.Close,
High = c.High,
Low = c.Low
}).ToList();
// Sort actual and expected result by DateTime
actualResult.Sort((x, y) => x.DateTime.CompareTo(y.DateTime));
expectedResult.Sort((x, y) => x.DateTime.CompareTo(y.DateTime));
// Assert actual result equals expected result
Assert.That(actualResult.Count, Is.EqualTo(expectedResult.Count));
Assert.Multiple(() =>
{
for (int i = 0; i < actualResult.Count; i++)
{
Assert.Multiple(() =>
{
Assert.That(actualResult[i].DateTime, Is.EqualTo(expectedResult[i].DateTime));
Assert.That(actualResult[i].Open, Is.EqualTo(expectedResult[i].Open));
Assert.That(actualResult[i].Close, Is.EqualTo(expectedResult[i].Close));
Assert.That(actualResult[i].High, Is.EqualTo(expectedResult[i].High));
Assert.That(actualResult[i].Low, Is.EqualTo(expectedResult[i].Low));
});
}
});
}
public async Task <bool> AlgoExists(AlgoDataDTO algoDataDTO)
{
List <AlgoEntity> allUserAlgos = await AlgoRepository.GetAllAsync(t => t.ClientId == algoDataDTO.ClientId) as List <AlgoEntity>;
return(allUserAlgos.Exists(x => x.AlgoId == algoDataDTO.Id));
}
