on.nemtina/DD.WellWorkover.Cloud
1
0
Fork 0
forked from ddrilling/AsbCloudServer
Code Pull Requests Activity

Рефакторинг тестов

Browse Source
This commit is contained in:
Степанов Дмитрий 2024-03-11 13:19:50 +03:00
parent 18c6cb316f
commit 3d828a2159
7 changed files with 735 additions and 825 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
AsbCloudWebApi.IntegrationTests/Controllers/AdminDepositControllerTest.cs
View File

@ -1,6 +1,5 @@
using System.Net; using System.Net;
using AsbCloudApp.Data; using AsbCloudApp.Data;
using AsbCloudDb.Model;
using AsbCloudWebApi.IntegrationTests.Clients; using AsbCloudWebApi.IntegrationTests.Clients;
using Mapster; using Mapster;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
@ -27,8 +26,6 @@ public class AdminDepositControllerTest : BaseIntegrationTest
: base(factory) : base(factory)
{ {
client = factory.GetAuthorizedHttpClient<IAdminDepositClient>(string.Empty); client = factory.GetAuthorizedHttpClient<IAdminDepositClient>(string.Empty);
dbContext.CleanupDbSet<Deposit>();
} }
[Fact] [Fact]
@ -130,11 +127,8 @@ public class AdminDepositControllerTest : BaseIntegrationTest
[Fact] [Fact]
public async Task GetOrDefault_returns_NoContent_for_IdDeposit() public async Task GetOrDefault_returns_NoContent_for_IdDeposit()
{ {
//arrange
const int idInvalid = 0;
//act //act
var responce = await client.GetOrDefaultAsync(idInvalid); var responce = await client.GetOrDefaultAsync(0);
//assert //assert
Assert.Equal(HttpStatusCode.NoContent, responce.StatusCode); Assert.Equal(HttpStatusCode.NoContent, responce.StatusCode);
@ -143,9 +137,6 @@ public class AdminDepositControllerTest : BaseIntegrationTest
[Fact] [Fact]
public async Task GetAll_returns_success() public async Task GetAll_returns_success()
{ {
//arrange
await client.InsertAsync(dto);
//act //act
var response = await client.GetAllAsync(); var response = await client.GetAllAsync();
@ -155,10 +146,6 @@ public class AdminDepositControllerTest : BaseIntegrationTest
var expectedCount = await dbContext.Deposits.CountAsync(); var expectedCount = await dbContext.Deposits.CountAsync();
Assert.Equal(expectedCount, response.Content.Count()); Assert.Equal(expectedCount, response.Content.Count());
var deposit = response.Content.First();
var excludeProps = new[] { nameof(DepositBaseDto.Id) };
MatchHelper.Match(dto, deposit, excludeProps);
} }
[Fact] [Fact]
@ -182,11 +169,8 @@ public class AdminDepositControllerTest : BaseIntegrationTest
[Fact] [Fact]
public async Task Delete_returns_NoContent_IdDeposit() public async Task Delete_returns_NoContent_IdDeposit()
{ {
//arrange
const int idInvalid = 0;
//act //act
var response = await client.DeleteAsync(idInvalid); var response = await client.DeleteAsync(0);
//assert //assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);

17
AsbCloudWebApi.IntegrationTests/Controllers/ProcessMapPlan/ProcessMapPlanDrillingControllerTest.cs
View File

@ -15,6 +15,8 @@ namespace AsbCloudWebApi.IntegrationTests.Controllers.ProcessMapPlan;
public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
{ {
private const int IdWell = 1;
private readonly ProcessMapPlanDrillingDto dto = new (){ private readonly ProcessMapPlanDrillingDto dto = new (){
Id = 0, Id = 0,
Creation = new(), Creation = new(),
@ -22,7 +24,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
IdState = 0, IdState = 0,
IdPrevious = null, IdPrevious = null,
IdWell = 1, IdWell = IdWell,
Section = "Кондуктор", Section = "Кондуктор",
IdWellSectionType = 3, IdWellSectionType = 3,
DepthStart = 0.5, DepthStart = 0.5,
@ -55,7 +57,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
IdState = AsbCloudDb.Model.ChangeLogAbstract.IdStateActual, IdState = AsbCloudDb.Model.ChangeLogAbstract.IdStateActual,
IdPrevious = null, IdPrevious = null,
IdWell = 1, IdWell = IdWell,
IdWellSectionType = 1, IdWellSectionType = 1,
DepthStart = 0.5, DepthStart = 0.5,
DepthEnd = 1.5, DepthEnd = 1.5,
@ -346,7 +348,6 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.InRange(actual.Obsolete.Value, startTime, doneTime); Assert.InRange(actual.Obsolete.Value, startTime, doneTime);
} }
[Fact] [Fact]
public async Task GetDatesChange_returns_success() public async Task GetDatesChange_returns_success()
{ {
@ -358,7 +359,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
dbset.Add(entity); dbset.Add(entity);
dbset.Add(entity2); dbset.Add(entity2);
dbContext.SaveChanges(); dbContext.SaveChanges();
var timezoneHours = Data.Defaults.Wells[0].Timezone.Hours; var timezoneHours = Defaults.Timezone.Hours;
var offset = TimeSpan.FromHours(timezoneHours); var offset = TimeSpan.FromHours(timezoneHours);
var dates = new[] { entity.Creation, entity2.Creation } var dates = new[] { entity.Creation, entity2.Creation }
.Select(d => d.ToOffset(offset)) .Select(d => d.ToOffset(offset))
@ -537,7 +538,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
dbContext.SaveChanges(); dbContext.SaveChanges();
var timezoneHours = Data.Defaults.Wells[0].Timezone.Hours; var timezoneHours = Defaults.Timezone.Hours;
var offset = TimeSpan.FromHours(timezoneHours); var offset = TimeSpan.FromHours(timezoneHours);
var updateFrom = entity.Creation.ToOffset(offset).AddHours(0.5); var updateFrom = entity.Creation.ToOffset(offset).AddHours(0.5);
@ -574,7 +575,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
//act //act
var streamPart = new StreamPart(stream, fileName, "application/octet-stream"); var streamPart = new StreamPart(stream, fileName, "application/octet-stream");
var response = await client.Parse(Defaults.Wells[0].Id, new[] { streamPart }); var response = await client.Parse(IdWell, new[] { streamPart });
//assert //assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -603,7 +604,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
//act //act
var streamPart = new StreamPart(stream, fileName, "application/octet-stream"); var streamPart = new StreamPart(stream, fileName, "application/octet-stream");
var response = await client.Parse(Defaults.Wells[0].Id, new[] { streamPart }); var response = await client.Parse(IdWell, new[] { streamPart });
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -619,4 +620,4 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.False(row.IsValid); Assert.False(row.IsValid);
Assert.Equal(2, row.Warnings.Count()); Assert.Equal(2, row.Warnings.Count());
} }
} }

505
AsbCloudWebApi.IntegrationTests/Controllers/ProcessMapPlan/ProcessMapReportDrillingControllerTest.cs
View File

@ -2,314 +2,255 @@
using AsbCloudDb.Model; using AsbCloudDb.Model;
using AsbCloudDb.Model.ProcessMaps; using AsbCloudDb.Model.ProcessMaps;
using AsbCloudWebApi.IntegrationTests.Clients; using AsbCloudWebApi.IntegrationTests.Clients;
using Org.BouncyCastle.Asn1.Ocsp;
using System.Net; using System.Net;
using System.Net.Http.Headers; using AsbCloudWebApi.IntegrationTests.Data;
using Xunit; using Xunit;
namespace AsbCloudWebApi.IntegrationTests.Controllers.ProcessMapPlan; namespace AsbCloudWebApi.IntegrationTests.Controllers.ProcessMapPlan;
public class ProcessMapReportDrillingControllerTest : BaseIntegrationTest public class ProcessMapReportDrillingControllerTest : BaseIntegrationTest
{ {
private IProcessMapReportDrilling client;
private readonly WellSectionType wellSection = new WellSectionType() public ProcessMapReportDrillingControllerTest(WebAppFactoryFixture factory)
{ : base(factory)
Id = 1, {
Caption = "Секция 1", dbContext.CleanupDbSet<DataSaubStat>();
Order = 1 dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
}; client = factory.GetAuthorizedHttpClient<IProcessMapReportDrilling>(string.Empty);
}
private readonly WellOperationCategory wellOperationCategory = new WellOperationCategory() [Fact]
{ public async Task Get_rtk_report_by_default_request_returns_success()
Id = 1, {
IdParent = null, //arrange
KeyValueName = "Name", var well = dbContext.Wells.First();
Name = "Name"
};
private readonly WellOperation wellOperation = new WellOperation() var processMapPlanDrilling = CreateProcessMapPlanDrilling(well.Id);
{ dbContext.ProcessMapPlanDrilling.Add(processMapPlanDrilling);
CategoryInfo = "CategoryInfo",
Id = 10,
Comment = "Comment",
DateStart = DateTimeOffset.UtcNow,
DepthEnd = 1,
DepthStart = 0.6,
DurationHours = 10,
IdCategory = 1,
IdPlan = null,
IdType = 1,
IdUser = 1,
IdWell = 1,
IdWellSectionType = 1,
LastUpdateDate = DateTimeOffset.UtcNow
};
private readonly List<DataSaubStat> dataSaubStats = new List<DataSaubStat>() var wellOperation = CreateWellOperation(well.Id);
{ dbContext.WellOperations.Add(wellOperation);
new DataSaubStat() var dataSaubStats = CreateDataSaubStats(well.IdTelemetry!.Value, wellOperation.IdCategory);
{ dbContext.DataSaubStat.AddRange(dataSaubStats);
AxialLoad = 0,
AxialLoadLimitMax = 10,
AxialLoadSp = 8,
BlockSpeedSp = 50.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(40),
DateStart = DateTimeOffset.UtcNow.AddMinutes(30),
DepthEnd = 85.99299621582031,
DepthStart = 85.9260025024414,
EnabledSubsystems = 0,
Flow = 10,
HasOscillation = true,
Id = 1,
IdCategory = 1,
IdFeedRegulator = 0,
IdTelemetry = 1,
Pressure = 24,
PressureIdle = 0,
PressureSp = 40,
RotorSpeed = 11.3,
RotorTorque = 1,
RotorTorqueLimitMax = 26.5,
RotorTorqueSp = 5,
Speed = 80.3924560546875
},
new DataSaubStat()
{
AxialLoad = 2,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 8,
BlockSpeedSp = 20,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(30),
DateStart = DateTimeOffset.UtcNow.AddMinutes(20),
DepthEnd = 86.28099822998047,
DepthStart = 86.21900177001953,
EnabledSubsystems = 1,
Flow = 20,
HasOscillation = true,
Id = 2,
IdCategory = 1,
IdFeedRegulator = 1,
IdTelemetry = 1,
Pressure = 30,
PressureIdle = 20,
PressureSp = 40,
RotorSpeed = 11.251153300212916,
RotorTorque = 7,
RotorTorqueLimitMax = 26.5,
RotorTorqueSp = 9,
Speed = 74.395751953125
},
new DataSaubStat()
{
AxialLoad = 4,
AxialLoadLimitMax = 15.0,
AxialLoadSp = 8,
BlockSpeedSp = 110.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(20),
DateStart = DateTimeOffset.UtcNow.AddMinutes(10),
DepthEnd = 106.7490005493164,
DepthStart = 106.47899627685547,
EnabledSubsystems = 1,
Flow = 30,
HasOscillation = true,
Id = 3,
IdCategory = 1,
IdFeedRegulator = 1,
IdTelemetry = 1,
Pressure = 36,
PressureIdle = 23.0,
PressureSp = 63.0,
RotorSpeed = 11.334207942999628,
RotorTorque = 14,
RotorTorqueLimitMax = 15.0,
RotorTorqueSp = 13,
Speed = 108.001708984375
}
};
await dbContext.SaveChangesAsync();
//act
var request = new DataSaubStatRequest();
var response = await client.GetReportAsync(well.Id, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(dataSaubStats.Count() - 1, response.Content.Count());
}
private readonly ProcessMapPlanDrilling entity = new() [Fact]
{ public async Task Get_rtk_report_by_parametrize_request_returns_success()
Id = 0, {
IdAuthor = 1, //arrange
IdEditor = null, var well = dbContext.Wells.First();
Creation = DateTimeOffset.UtcNow,
Obsolete = null,
IdState = AsbCloudDb.Model.ChangeLogAbstract.IdStateActual,
IdPrevious = null,
IdWell = 1, var processMapPlanDrilling = CreateProcessMapPlanDrilling(well.Id);
IdWellSectionType = 1, dbContext.ProcessMapPlanDrilling.Add(processMapPlanDrilling);
DepthStart = 0.5,
DepthEnd = 1.5,
IdMode = 1, var wellOperation = CreateWellOperation(well.Id);
AxialLoadPlan = 2.718281, dbContext.WellOperations.Add(wellOperation);
AxialLoadLimitMax = 3.1415926,
DeltaPressurePlan = 4,
DeltaPressureLimitMax = 5,
TopDriveTorquePlan = 6,
TopDriveTorqueLimitMax = 7,
TopDriveSpeedPlan = 8,
TopDriveSpeedLimitMax = 9,
FlowPlan = 10,
FlowLimitMax = 11,
RopPlan = 12,
UsageSaub = 13,
UsageSpin = 14,
Comment = "это тестовая запись",
};
private IProcessMapReportDrilling client; var dataSaubStats = CreateDataSaubStats(well.IdTelemetry!.Value, wellOperation.IdCategory);
dbContext.DataSaubStat.AddRange(dataSaubStats);
public ProcessMapReportDrillingControllerTest(WebAppFactoryFixture factory) : base(factory) await dbContext.SaveChangesAsync();
{
client = factory.GetAuthorizedHttpClient<IProcessMapReportDrilling>(string.Empty); var request = new DataSaubStatRequest
} {
DeltaAxialLoad = 5,
DeltaPressure = 15,
DeltaRotorTorque = 10
};
//act
var response = await client.GetReportAsync(well.Id, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(1, response.Content.Count());
}
[Fact]
public async Task Get_rtk_report_returns_BadRequest()
{
//act
var request = new DataSaubStatRequest()
{
DeltaAxialLoad = 15,
DeltaPressure = 25,
DeltaRotorTorque = 20
};
var response = await client.GetReportAsync(0, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task Export_rtk_report_returns_success()
{
//arrange
var well = dbContext.Wells.First();
var processMapPlanDrilling = CreateProcessMapPlanDrilling(well.Id);
dbContext.ProcessMapPlanDrilling.Add(processMapPlanDrilling);
[Fact] var wellOperation = CreateWellOperation(well.Id);
public async Task Get_rtk_report_by_default_request_returns_success() dbContext.WellOperations.Add(wellOperation);
{
//arrange
dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
dbset.Add(entity);
entity.Id = 1;
dbset.Add(entity);
entity.Id = 2;
dbset.Add(entity);
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>(); var dataSaubStats = CreateDataSaubStats(well.IdTelemetry!.Value, wellOperation.IdCategory);
dbSetWellOperationCategory.Add(wellOperationCategory); dbContext.DataSaubStat.AddRange(dataSaubStats);
var dbSetWellOperation = dbContext.Set<WellOperation>(); await dbContext.SaveChangesAsync();
dbSetWellOperation.Add(wellOperation);
//act
var request = new DataSaubStatRequest();
var response = await client.ExportReportAsync(1, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/octet-stream", response.ContentHeaders?.ContentType?.MediaType);
Assert.True(response.ContentHeaders?.ContentLength > 0);
}
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>(); private static WellOperation CreateWellOperation(int idWell) =>
dbSetDataSaubStat.AddRange(dataSaubStats); new()
{
CategoryInfo = "CategoryInfo",
Comment = "Comment",
DateStart = DateTimeOffset.UtcNow,
DepthEnd = 1,
DepthStart = 0.6,
DurationHours = 10,
IdCategory = WellOperationCategory.IdSlide,
IdPlan = null,
IdType = WellOperation.IdOperationTypeFact,
IdUser = 1,
IdWell = idWell,
IdWellSectionType = 1,
LastUpdateDate = DateTimeOffset.UtcNow
};
dbContext.SaveChanges(); private static ProcessMapPlanDrilling CreateProcessMapPlanDrilling(int idWell) =>
new()
{
IdAuthor = 1,
IdEditor = null,
Creation = DateTimeOffset.UtcNow,
Obsolete = null,
IdState = ChangeLogAbstract.IdStateActual,
IdPrevious = null,
//act IdWell = idWell,
var request = new DataSaubStatRequest(); IdWellSectionType = 1,
var response = await client.GetReportAsync(1, request, CancellationToken.None); DepthStart = 0.5,
DepthEnd = 1.5,
//assert IdMode = 1,
Assert.Equal(HttpStatusCode.OK, response.StatusCode); AxialLoadPlan = 2.718281,
Assert.NotNull(response.Content); AxialLoadLimitMax = 3.1415926,
Assert.Equal(dataSaubStats.Count() - 1, response.Content.Count()); DeltaPressurePlan = 4,
} DeltaPressureLimitMax = 5,
TopDriveTorquePlan = 6,
TopDriveTorqueLimitMax = 7,
TopDriveSpeedPlan = 8,
TopDriveSpeedLimitMax = 9,
FlowPlan = 10,
FlowLimitMax = 11,
RopPlan = 12,
UsageSaub = 13,
UsageSpin = 14,
Comment = "это тестовая запись",
};
[Fact] private static IEnumerable<DataSaubStat> CreateDataSaubStats(int idTelemetry,
public async Task Get_rtk_report_by_parametrize_request_returns_success() int idCategory) =>
{ new[]
//arrange {
dbContext.CleanupDbSet<ProcessMapPlanDrilling>(); new DataSaubStat
var dbset = dbContext.Set<ProcessMapPlanDrilling>(); {
dbset.Add(entity); AxialLoad = 0,
entity.Id = 1; AxialLoadLimitMax = 10,
dbset.Add(entity); AxialLoadSp = 8,
entity.Id = 2; BlockSpeedSp = 50.0,
dbset.Add(entity); DateEnd = DateTimeOffset.UtcNow.AddMinutes(40),
DateStart = DateTimeOffset.UtcNow.AddMinutes(30),
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>(); DepthEnd = 85.99299621582031,
dbSetWellOperationCategory.Add(wellOperationCategory); DepthStart = 85.9260025024414,
EnabledSubsystems = 0,
var dbSetWellOperation = dbContext.Set<WellOperation>(); Flow = 10,
dbSetWellOperation.Add(wellOperation); IdCategory = idCategory,
HasOscillation = true,
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>(); IdFeedRegulator = 0,
dbSetDataSaubStat.AddRange(dataSaubStats); IdTelemetry = idTelemetry,
Pressure = 24,
dbContext.SaveChanges(); PressureIdle = 0,
PressureSp = 40,
//act RotorSpeed = 11.3,
var request = new DataSaubStatRequest() RotorTorque = 1,
{ RotorTorqueLimitMax = 26.5,
DeltaAxialLoad = 5, RotorTorqueSp = 5,
DeltaPressure = 15, Speed = 80.3924560546875
DeltaRotorTorque = 10 },
}; new DataSaubStat
var response = await client.GetReportAsync(1, request, CancellationToken.None); {
AxialLoad = 2,
//assert AxialLoadLimitMax = 10.0,
Assert.Equal(HttpStatusCode.OK, response.StatusCode); AxialLoadSp = 8,
Assert.NotNull(response.Content); BlockSpeedSp = 20,
Assert.Equal(1, response.Content.Count()); DateEnd = DateTimeOffset.UtcNow.AddMinutes(30),
} DateStart = DateTimeOffset.UtcNow.AddMinutes(20),
DepthEnd = 86.28099822998047,
[Fact] DepthStart = 86.21900177001953,
public async Task Get_rtk_report_returns_BadRequest() EnabledSubsystems = 1,
{ Flow = 20,
//arrange HasOscillation = true,
dbContext.CleanupDbSet<ProcessMapPlanDrilling>(); IdCategory = idCategory,
var dbset = dbContext.Set<ProcessMapPlanDrilling>(); IdFeedRegulator = 1,
dbset.Add(entity); IdTelemetry = idTelemetry,
entity.Id = 1; Pressure = 30,
dbset.Add(entity); PressureIdle = 20,
entity.Id = 2; PressureSp = 40,
dbset.Add(entity); RotorSpeed = 11.251153300212916,
RotorTorque = 7,
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>(); RotorTorqueLimitMax = 26.5,
dbSetWellOperationCategory.Add(wellOperationCategory); RotorTorqueSp = 9,
Speed = 74.395751953125
var dbSetWellOperation = dbContext.Set<WellOperation>(); },
dbSetWellOperation.Add(wellOperation); new DataSaubStat
{
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>(); AxialLoad = 4,
dbSetDataSaubStat.AddRange(dataSaubStats); AxialLoadLimitMax = 15.0,
AxialLoadSp = 8,
dbContext.SaveChanges(); BlockSpeedSp = 110.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(20),
//act DateStart = DateTimeOffset.UtcNow.AddMinutes(10),
var request = new DataSaubStatRequest() DepthEnd = 106.7490005493164,
{ DepthStart = 106.47899627685547,
DeltaAxialLoad = 15, EnabledSubsystems = 1,
DeltaPressure = 25, Flow = 30,
DeltaRotorTorque = 20 HasOscillation = true,
}; IdFeedRegulator = 1,
var response = await client.GetReportAsync(1, request, CancellationToken.None); IdTelemetry = idTelemetry,
IdCategory = idCategory,
//assert Pressure = 36,
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); PressureIdle = 23.0,
} PressureSp = 63.0,
RotorSpeed = 11.334207942999628,
[Fact] RotorTorque = 14,
public async Task Export_rtk_report_returns_success() RotorTorqueLimitMax = 15.0,
{ RotorTorqueSp = 13,
//clear Speed = 108.001708984375
dbContext.CleanupDbSet<ProcessMapPlanDrilling>(); }
};
//arrange }
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
dbset.Add(entity);
entity.Id = 1;
dbset.Add(entity);
entity.Id = 2;
dbset.Add(entity);
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>();
dbSetWellOperationCategory.Add(wellOperationCategory);
var dbSetWellOperation = dbContext.Set<WellOperation>();
dbSetWellOperation.Add(wellOperation);
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>();
dbSetDataSaubStat.AddRange(dataSaubStats);
dbContext.SaveChanges();
//act
var request = new DataSaubStatRequest();
var response = await client.ExportReportAsync(1, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/octet-stream", response.ContentHeaders?.ContentType?.MediaType);
Assert.True(response.ContentHeaders?.ContentLength > 0);
}
}

456
AsbCloudWebApi.IntegrationTests/Controllers/ScheduleControllerTest.cs
View File

@ -1,228 +1,228 @@
using AsbCloudApp.Data; // using AsbCloudApp.Data;
using AsbCloudDb.Model; // using AsbCloudDb.Model;
using AsbCloudInfrastructure; // using AsbCloudInfrastructure;
using AsbCloudWebApi.IntegrationTests.Clients; // using AsbCloudWebApi.IntegrationTests.Clients;
using Mapster; // using Mapster;
using Microsoft.EntityFrameworkCore; // using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking; // using Microsoft.EntityFrameworkCore.ChangeTracking;
using System.Net; // using System.Net;
using Xunit; // using Xunit;
//
namespace AsbCloudWebApi.IntegrationTests.Controllers // namespace AsbCloudWebApi.IntegrationTests.Controllers
{ // {
public abstract class CrudWellRelatedClient<TDto, TEntity> : BaseIntegrationTest // public abstract class CrudWellRelatedClient<TDto, TEntity> : BaseIntegrationTest
where TDto : AsbCloudApp.Data.IId, AsbCloudApp.Data.IWellRelated // where TDto : AsbCloudApp.Data.IId, AsbCloudApp.Data.IWellRelated
where TEntity : class, AsbCloudDb.Model.IId, AsbCloudDb.Model.IWellRelated // where TEntity : class, AsbCloudDb.Model.IId, AsbCloudDb.Model.IWellRelated
{ // {
public abstract IEnumerable<TDto> ValidDtos { get; } // public abstract IEnumerable<TDto> ValidDtos { get; }
public abstract IEnumerable<TDto> InvalidDtos { get; } // public abstract IEnumerable<TDto> InvalidDtos { get; }
public abstract IEnumerable<TDto> ForbiddenDtos { get; } // public abstract IEnumerable<TDto> ForbiddenDtos { get; }
protected List<string> ExcludeProps { get; set; } = new() { "Id" }; // protected List<string> ExcludeProps { get; set; } = new() { "Id" };
//
protected ICrudWellRelatedClient<TDto> client; // protected ICrudWellRelatedClient<TDto> client;
//
public CrudWellRelatedClient(WebAppFactoryFixture factory, string uriSuffix) // public CrudWellRelatedClient(WebAppFactoryFixture factory, string uriSuffix)
: base(factory) // : base(factory)
{ // {
client = factory.GetAuthorizedHttpClient<ICrudWellRelatedClient<TDto>>(uriSuffix); // client = factory.GetAuthorizedHttpClient<ICrudWellRelatedClient<TDto>>(uriSuffix);
} // }
//
protected async Task<DbSet<TEntity>> GetCleanDbSet() // protected async Task<DbSet<TEntity>> GetCleanDbSet()
{ // {
var dbset = dbContext.Set<TEntity>(); // var dbset = dbContext.Set<TEntity>();
dbset.RemoveRange(dbset); // dbset.RemoveRange(dbset);
await dbContext.SaveChangesAsync(CancellationToken.None); // await dbContext.SaveChangesAsync(CancellationToken.None);
return dbset; // return dbset;
} // }
//
[Fact] // [Fact]
public async Task Insert_returns_success_for_validDtos() // public async Task Insert_returns_success_for_validDtos()
{ // {
foreach (var validDto in ValidDtos) // foreach (var validDto in ValidDtos)
await Insert_returns_success(validDto); // await Insert_returns_success(validDto);
} // }
//
private async Task Insert_returns_success(TDto validDto) // private async Task Insert_returns_success(TDto validDto)
{ // {
var dbset = await GetCleanDbSet(); // var dbset = await GetCleanDbSet();
//
//act // //act
var response = await client.InsertAsync(validDto); // var response = await client.InsertAsync(validDto);
//
//assert // //assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode); // Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(response.Content > 0); // Assert.True(response.Content > 0);
//
var entity = dbset.First(); // var entity = dbset.First();
var fromDbDto = Convert(entity); // var fromDbDto = Convert(entity);
MatchHelper.Match(validDto, fromDbDto, ExcludeProps); // MatchHelper.Match(validDto, fromDbDto, ExcludeProps);
} // }
//
[Fact] // [Fact]
public async Task Insert_returns_badRequest_for_invalidDtos() // public async Task Insert_returns_badRequest_for_invalidDtos()
{ // {
foreach (var inValidDto in InvalidDtos) // foreach (var inValidDto in InvalidDtos)
await Insert_returns_badRequest(inValidDto); // await Insert_returns_badRequest(inValidDto);
} // }
//
private async Task Insert_returns_badRequest(TDto invalidDto) // private async Task Insert_returns_badRequest(TDto invalidDto)
{ // {
await GetCleanDbSet(); // await GetCleanDbSet();
//
//act // //act
var response = await client.InsertAsync(invalidDto); // var response = await client.InsertAsync(invalidDto);
//
//assert // //assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); // Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
} // }
//
[Fact] // [Fact]
public async Task Insert_returns_forbidden_for_forbiddenDtos() // public async Task Insert_returns_forbidden_for_forbiddenDtos()
{ // {
foreach (var forbiddenDto in ForbiddenDtos) // foreach (var forbiddenDto in ForbiddenDtos)
await Insert_returns_forbidden(forbiddenDto); // await Insert_returns_forbidden(forbiddenDto);
} // }
//
private async Task Insert_returns_forbidden(TDto forbiddenDto) // private async Task Insert_returns_forbidden(TDto forbiddenDto)
{ // {
await GetCleanDbSet(); // await GetCleanDbSet();
//
//act // //act
var response = await client.InsertAsync(forbiddenDto); // var response = await client.InsertAsync(forbiddenDto);
//
//assert // //assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); // Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
} // }
//
[Fact] // [Fact]
public async Task GetAllAsync_returns_data() // public async Task GetAllAsync_returns_data()
{ // {
//arrange // //arrange
var dbset = await GetCleanDbSet(); // var dbset = await GetCleanDbSet();
var entries = new List<(EntityEntry<TEntity>, TDto)>(); // var entries = new List<(EntityEntry<TEntity>, TDto)>();
//
foreach (var dto in ValidDtos) // foreach (var dto in ValidDtos)
{ // {
var entity = Convert(dto); // var entity = Convert(dto);
entity.Id = 0; // entity.Id = 0;
var entry = dbset.Add(entity); // var entry = dbset.Add(entity);
entries.Add((entry, dto)); // entries.Add((entry, dto));
} // }
dbContext.SaveChanges(); // dbContext.SaveChanges();
//
//act // //act
var response = await client.GetAllAsync(); // var response = await client.GetAllAsync();
//
//assert // //assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode); // Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content); // Assert.NotNull(response.Content);
Assert.Equal(entries.Count, response.Content.Count()); // Assert.Equal(entries.Count, response.Content.Count());
//
foreach (var item in response.Content) // foreach (var item in response.Content)
{ // {
var entry = entries.First(e => e.Item1.Entity.Id == item.Id); // var entry = entries.First(e => e.Item1.Entity.Id == item.Id);
MatchHelper.Match(entry.Item2, item, ExcludeProps); // MatchHelper.Match(entry.Item2, item, ExcludeProps);
} // }
} // }
//
protected virtual TDto Convert(TEntity entity) // protected virtual TDto Convert(TEntity entity)
{ // {
var dto = entity.Adapt<TDto>(); // var dto = entity.Adapt<TDto>();
return dto; // return dto;
} // }
//
protected virtual TEntity Convert(TDto dto) // protected virtual TEntity Convert(TDto dto)
{ // {
var entity = dto.Adapt<TEntity>(); // var entity = dto.Adapt<TEntity>();
return entity; // return entity;
} // }
} // }
//
public class ScheduleControllerTest : CrudWellRelatedClient<ScheduleDto, Schedule> // public class ScheduleControllerTest : CrudWellRelatedClient<ScheduleDto, Schedule>
{ // {
static Driller driller = Data.Defaults.Drillers.First(); // static Driller driller = Data.Defaults.Drillers.First();
static DrillerDto drillerDto = driller.Adapt<DrillerDto>(); // static DrillerDto drillerDto = driller.Adapt<DrillerDto>();
//
static Well well = Data.Defaults.Wells.First(); // static Well well = Data.Defaults.Wells.First();
//
public override IEnumerable<ScheduleDto> ValidDtos { get; } = new ScheduleDto[] // public override IEnumerable<ScheduleDto> ValidDtos { get; } = new ScheduleDto[]
{ // {
new() { // new() {
Id = 1, // Id = 1,
IdWell = well.Id, // IdWell = well.Id,
Driller = drillerDto, // Driller = drillerDto,
IdDriller = driller.Id, // IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified), // DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified), // DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0), // ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0), // ShiftEnd = new TimeDto(20, 0, 0),
}, // },
new() { // new() {
Id = 1, // Id = 1,
IdWell = well.Id, // IdWell = well.Id,
Driller = drillerDto, // Driller = drillerDto,
IdDriller = driller.Id, // IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified), // DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified), // DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(20, 0, 0), // ShiftStart = new TimeDto(20, 0, 0),
ShiftEnd = new TimeDto(8, 0, 0), // ShiftEnd = new TimeDto(8, 0, 0),
} // }
}; // };
//
public override IEnumerable<ScheduleDto> InvalidDtos { get; } = new ScheduleDto[] // public override IEnumerable<ScheduleDto> InvalidDtos { get; } = new ScheduleDto[]
{ // {
new() { // new() {
IdWell = well.Id, // IdWell = well.Id,
Driller = drillerDto, // Driller = drillerDto,
IdDriller = driller.Id, // IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified), // DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified), // DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0), // ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0), // ShiftEnd = new TimeDto(20, 0, 0),
}, // },
new() { // new() {
IdWell = well.Id, // IdWell = well.Id,
Driller = drillerDto, // Driller = drillerDto,
IdDriller = int.MaxValue - 1, // IdDriller = int.MaxValue - 1,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified), // DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified), // DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0), // ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0), // ShiftEnd = new TimeDto(20, 0, 0),
} // }
}; // };
//
public override IEnumerable<ScheduleDto> ForbiddenDtos { get; } = new ScheduleDto[] { // public override IEnumerable<ScheduleDto> ForbiddenDtos { get; } = new ScheduleDto[] {
new() { // new() {
IdWell = int.MaxValue - 1, // IdWell = int.MaxValue - 1,
Driller = drillerDto, // Driller = drillerDto,
IdDriller = driller.Id, // IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified), // DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified), // DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0), // ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0), // ShiftEnd = new TimeDto(20, 0, 0),
} // }
}; // };
//
public ScheduleControllerTest(WebAppFactoryFixture factory) // public ScheduleControllerTest(WebAppFactoryFixture factory)
: base(factory, "api/schedule") // : base(factory, "api/schedule")
{ // {
ExcludeProps.Add(nameof(ScheduleDto.Driller)); // ExcludeProps.Add(nameof(ScheduleDto.Driller));
} // }
//
protected override ScheduleDto Convert(Schedule entity) // protected override ScheduleDto Convert(Schedule entity)
{ // {
var dto = base.Convert(entity); // var dto = base.Convert(entity);
dto.DrillStart = entity.DrillStart.ToRemoteDateTime(well.Timezone.Hours); // dto.DrillStart = entity.DrillStart.ToRemoteDateTime(well.Timezone.Hours);
dto.DrillEnd = entity.DrillEnd.ToRemoteDateTime(well.Timezone.Hours); // dto.DrillEnd = entity.DrillEnd.ToRemoteDateTime(well.Timezone.Hours);
return dto; // return dto;
} // }
//
protected override Schedule Convert(ScheduleDto dto) // protected override Schedule Convert(ScheduleDto dto)
{ // {
var entity = base.Convert(dto); // var entity = base.Convert(dto);
entity.DrillStart = dto.DrillStart.FromTimeZoneOffsetHours(well.Timezone.Hours); // entity.DrillStart = dto.DrillStart.FromTimeZoneOffsetHours(well.Timezone.Hours);
entity.DrillEnd = dto.DrillEnd.FromTimeZoneOffsetHours(well.Timezone.Hours); // entity.DrillEnd = dto.DrillEnd.FromTimeZoneOffsetHours(well.Timezone.Hours);
return entity; // return entity;
} // }
} // }
} // }

111
AsbCloudWebApi.IntegrationTests/Controllers/SlipsStatControllerTest.cs
View File

@ -2,77 +2,38 @@ using AsbCloudApp.Data;
using AsbCloudApp.Requests; using AsbCloudApp.Requests;
using AsbCloudDb.Model; using AsbCloudDb.Model;
using AsbCloudWebApi.IntegrationTests.Clients; using AsbCloudWebApi.IntegrationTests.Clients;
using Microsoft.EntityFrameworkCore;
using Xunit; using Xunit;
namespace AsbCloudWebApi.IntegrationTests.Controllers; namespace AsbCloudWebApi.IntegrationTests.Controllers;
public class SlipsStatControllerTest : BaseIntegrationTest public class SlipsStatControllerTest : BaseIntegrationTest
{ {
private static readonly Schedule schedule = new()
{
Id = 0,
IdDriller = Data.Defaults.Drillers[0].Id,
IdWell = Data.Defaults.Wells[0].Id,
ShiftStart = new TimeOnly(8, 0, 0),
ShiftEnd = new TimeOnly(20, 0, 0),
DrillStart = new DateTimeOffset(new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
DrillEnd = new DateTimeOffset(new DateTime(2024, 2, 1, 0, 0, 0, DateTimeKind.Utc))
};
private static readonly DetectedOperation detectedOperation = new()
{
Id = 0,
IdTelemetry = Data.Defaults.Telemetries[0].Id,
IdCategory = WellOperationCategory.IdSlipsTime,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 0, 0, 0, DateTimeKind.Utc)),
DateEnd = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 2, 0, 0, DateTimeKind.Utc)),
ExtraData = new Dictionary<string, object>
{
{ "test", 5 }
}
};
private static readonly WellOperation factWellOperation = new()
{
Id = 0,
IdWell = Data.Defaults.Wells[0].Id,
IdWellSectionType = 1,
IdCategory = WellOperationCategory.IdRotor,
IdType = WellOperation.IdOperationTypeFact,
DepthStart = 0,
DepthEnd = 100,
LastUpdateDate = DateTimeOffset.UtcNow,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 15, 15, 0, 0, DateTimeKind.Utc)),
DurationHours = 1
};
private readonly ISlipsTimeClient client; private readonly ISlipsTimeClient client;
public SlipsStatControllerTest(WebAppFactoryFixture factory) public SlipsStatControllerTest(WebAppFactoryFixture factory)
: base(factory) : base(factory)
{ {
var schedules = dbContext.Set<Schedule>();
var detectedOperations = dbContext.Set<DetectedOperation>();
var wellOperations = dbContext.Set<WellOperation>();
schedules.RemoveRange(schedules);
detectedOperations.RemoveRange(detectedOperations);
wellOperations.RemoveRange(wellOperations);
dbContext.SaveChanges();
schedules.Add(schedule);
detectedOperations.Add(detectedOperation);
wellOperations.Add(factWellOperation);
dbContext.SaveChanges();
client = factory.GetAuthorizedHttpClient<ISlipsTimeClient>(string.Empty); client = factory.GetAuthorizedHttpClient<ISlipsTimeClient>(string.Empty);
dbContext.CleanupDbSet<Schedule>();
dbContext.CleanupDbSet<WellOperation>();
dbContext.CleanupDbSet<DetectedOperation>();
} }
[Fact] [Fact]
public async Task GetAll_returns_success() public async Task GetAll_returns_success()
{ {
//arrange //arrange
var well = dbContext.Wells.First();
var schedule = CreateScheduleAsync(well.Id);
var factWellOperation = CreateFactWellOperation(well.Id);
var detectedOperation = CreateDetectedOperation(well.IdTelemetry!.Value);
dbContext.Schedule.Add(schedule);
dbContext.WellOperations.Add(factWellOperation);
dbContext.DetectedOperations.Add(detectedOperation);
await dbContext.SaveChangesAsync();
var request = new OperationStatRequest var request = new OperationStatRequest
{ {
DateStartUTC = schedule.DrillStart.DateTime, DateStartUTC = schedule.DrillStart.DateTime,
@ -83,7 +44,7 @@ public class SlipsStatControllerTest : BaseIntegrationTest
var dtoExpected = new SlipsStatDto var dtoExpected = new SlipsStatDto
{ {
DrillerName = $"{Data.Defaults.Drillers[0].Surname} {Data.Defaults.Drillers[0].Name} {Data.Defaults.Drillers[0].Patronymic}", DrillerName = $"{schedule.Driller.Surname} {schedule.Driller.Name} {schedule.Driller.Patronymic}",
WellCount = 1, WellCount = 1,
SectionCaption = "Пилотный ствол", SectionCaption = "Пилотный ствол",
SlipsCount = 1, SlipsCount = 1,
@ -101,4 +62,46 @@ public class SlipsStatControllerTest : BaseIntegrationTest
var slipsStat = response.Content.First(); var slipsStat = response.Content.First();
MatchHelper.Match(dtoExpected, slipsStat); MatchHelper.Match(dtoExpected, slipsStat);
} }
private static Schedule CreateScheduleAsync(int idWell) => new()
{
IdWell = idWell,
ShiftStart = new TimeOnly(8, 0, 0),
ShiftEnd = new TimeOnly(20, 0, 0),
DrillStart = new DateTimeOffset(new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
DrillEnd = new DateTimeOffset(new DateTime(2024, 2, 1, 0, 0, 0, DateTimeKind.Utc)),
Driller = new Driller
{
Name = "TestName",
Surname = "TestSurname",
Patronymic = "TestPatronymic"
}
};
private static WellOperation CreateFactWellOperation(int idWell) =>
new()
{
IdWell = idWell,
IdWellSectionType = 1,
IdCategory = WellOperationCategory.IdRotor,
IdType = WellOperation.IdOperationTypeFact,
DepthStart = 0,
DepthEnd = 100,
LastUpdateDate = DateTimeOffset.UtcNow,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 15, 15, 0, 0, DateTimeKind.Utc)),
DurationHours = 1
};
private static DetectedOperation CreateDetectedOperation(int idTelemetry) =>
new()
{
IdTelemetry = idTelemetry,
IdCategory = WellOperationCategory.IdSlipsTime,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 0, 0, 0, DateTimeKind.Utc)),
DateEnd = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 2, 0, 0, DateTimeKind.Utc)),
ExtraData = new Dictionary<string, object>
{
{ "test", 5 }
}
};
} }

197
AsbCloudWebApi.IntegrationTests/Controllers/WellOperationControllerTest.cs
View File

@ -5,6 +5,8 @@ using System.Net;
using System.Reflection; using System.Reflection;
using AsbCloudApp.Requests; using AsbCloudApp.Requests;
using AsbCloudWebApi.IntegrationTests.Data; using AsbCloudWebApi.IntegrationTests.Data;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Refit; using Refit;
using Xunit; using Xunit;
@ -12,85 +14,76 @@ namespace AsbCloudWebApi.IntegrationTests.Controllers;
public class WellOperationControllerTest : BaseIntegrationTest public class WellOperationControllerTest : BaseIntegrationTest
{ {
private static int idWell = 1;
private readonly WellOperationDto[] dtos = new WellOperationDto[]
{
new()
{
IdWell = 1,
IdWellSectionType = 1,
WellSectionTypeName = "Пилотный ствол",
IdCategory = 5000,
IdPlan = null,
CategoryName = "Разборка КНБК",
IdParentCategory = 4000,
CategoryInfo = "1",
IdType = 0,
DepthStart = 10.0,
DepthEnd = 20.0,
Day = 0.0,
NptHours = 0.0,
DateStart = new DateTimeOffset(new DateTime(2023, 1, 10), TimeSpan.FromHours(Defaults.Wells[0].Timezone.Hours)),
DurationHours = 1.0,
Comment = "1",
IdUser = 1,
UserName = null,
}
};
private IWellOperationClient client; private IWellOperationClient client;
public WellOperationControllerTest(WebAppFactoryFixture factory) public WellOperationControllerTest(WebAppFactoryFixture factory)
: base(factory) : base(factory)
{ {
client = factory.GetAuthorizedHttpClient<IWellOperationClient>(string.Empty); client = factory.GetAuthorizedHttpClient<IWellOperationClient>(string.Empty);
}
/// <summary> dbContext.CleanupDbSet<WellOperation>();
/// Успешное добавление операций (без предварительной очистки данных) }
/// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRange_returns_success()
{
dbContext.CleanupDbSet<WellOperation>();
//act
var response = await client.InsertRangeAsync(idWell, 1, false, dtos);
//assert /// <summary>
Assert.Equal(HttpStatusCode.OK, response.StatusCode); /// Успешное добавление операций (без предварительной очистки данных)
} /// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRange_returns_success()
{
//arrange
var well = await dbContext.Wells.FirstAsync();
var entity = CreateWellOperation(well.Id);
var dtos = new[] { entity.Adapt<WellOperationDto>() };
/// <summary> //act
/// Успешное добавление операций (с предварительной очисткой данных) var response = await client.InsertRangeAsync(well.Id, 1, false, dtos);
/// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRangeWithDeleteBefore_returns_success()
{
//act
var response = await client.InsertRangeAsync(idWell, 1, true, dtos);
//assert //assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
} }
/// <summary> /// <summary>
/// Успешное обновление операции /// Успешное добавление операций (с предварительной очисткой данных)
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
[Fact] [Fact]
public async Task UpdateAsync_returns_success() public async Task InsertRangeWithDeleteBefore_returns_success()
{ {
//act //arrange
var dto = dtos.FirstOrDefault()!; var well = await dbContext.Wells.FirstAsync();
var response = await client.UpdateAsync(idWell, 1, dto, CancellationToken.None); var entity = CreateWellOperation(well.Id);
var dtos = new[] { entity.Adapt<WellOperationDto>() };
//act
var response = await client.InsertRangeAsync(well.Id, 1, true, dtos);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary>
/// Успешное обновление операции
/// </summary>
/// <returns></returns>
[Fact]
public async Task UpdateAsync_returns_success()
{
//arrange
var well = await dbContext.Wells.FirstAsync();
var entity = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(entity);
await dbContext.SaveChangesAsync();
var dto = entity.Adapt<WellOperationDto>();
//act
var response = await client.UpdateAsync(well.Id, entity.Id, dto, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary> /// <summary>
/// Получение плановых операций /// Получение плановых операций
/// </summary> /// </summary>
@ -99,8 +92,14 @@ public class WellOperationControllerTest : BaseIntegrationTest
public async Task GetPageOperationsPlanAsync_returns_success() public async Task GetPageOperationsPlanAsync_returns_success()
{ {
//arrange //arrange
dbContext.CleanupDbSet<WellOperation>(); var well = await dbContext.Wells.FirstAsync();
await client.InsertRangeAsync(idWell, WellOperation.IdOperationTypePlan, false, dtos); var entity = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(entity);
await dbContext.SaveChangesAsync();
var dto = entity.Adapt<WellOperationDto>();
var timezoneOffset = TimeSpan.FromHours(well.Timezone.Hours);
dto.DateStart = dto.DateStart.ToOffset(timezoneOffset);
var request = new WellOperationRequestBase var request = new WellOperationRequestBase
{ {
@ -108,49 +107,59 @@ public class WellOperationControllerTest : BaseIntegrationTest
}; };
//act //act
var response = await client.GetPageOperationsPlanAsync(idWell, request, CancellationToken.None); var response = await client.GetPageOperationsPlanAsync(well.Id, request, CancellationToken.None);
//assert //assert
Assert.NotNull(response.Content); Assert.NotNull(response.Content);
Assert.Single(response.Content.Items); Assert.Single(response.Content.Items);
var dto = dtos[0]; var actualDto = response.Content.Items.First();
var wellOperation = response.Content.Items.First();
var excludeProps = new[] { nameof(WellOperationDto.Id) }; var excludeProps = new[]
MatchHelper.Match(dto, wellOperation, excludeProps); {
nameof(WellOperationDto.LastUpdateDate)
};
MatchHelper.Match(dto, actualDto, excludeProps);
} }
[Fact] [Fact]
public async Task ImportPlanDefaultExcelFileAsync_returns_success() public async Task ImportPlanDefaultExcelFileAsync_returns_success()
{ {
//arrange //arrange
//TODO: вынести в метод расширения. Сделать когда доберёмся до рефакторинга операций по скважине var stream = Assembly.GetExecutingAssembly().GetFileCopyStream("WellOperationsPlan.xlsx");
var resourceName = Assembly.GetExecutingAssembly()
.GetManifestResourceNames()
.FirstOrDefault(n => n.EndsWith("WellOperationsPlan.xlsx"));
if (string.IsNullOrWhiteSpace(resourceName))
throw new ArgumentNullException(nameof(resourceName));
var stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream(resourceName);
if (stream is null)
throw new ArgumentNullException(nameof(stream));
var memoryStream = new MemoryStream(); var memoryStream = new MemoryStream();
stream.CopyTo(memoryStream); await stream.CopyToAsync(memoryStream);
memoryStream.Position = 0; memoryStream.Position = 0;
var well = await dbContext.Wells.FirstAsync();
//act //act
var streamPart = new StreamPart(memoryStream, "WellOperations.xlsx", "application/octet-stream"); var streamPart = new StreamPart(memoryStream, "WellOperations.xlsx", "application/octet-stream");
var response = await client.ImportPlanDefaultExcelFileAsync(idWell, new[] { streamPart }, CancellationToken.None); var response = await client.ImportPlanDefaultExcelFileAsync(well.Id, new[] { streamPart }, CancellationToken.None);
//assert //assert
Assert.NotNull(response.Content); Assert.NotNull(response.Content);
Assert.Equal(4, response.Content.Count()); Assert.Equal(4, response.Content.Count());
Assert.True(response.Content.All(w => Math.Abs(w.DateStart.Offset.Hours - Defaults.Wells[0].Timezone.Hours) < 0.1)); Assert.True(response.Content.All(w => Math.Abs(w.DateStart.Offset.Hours - Defaults.Timezone.Hours) < 0.1));
} }
private static WellOperation CreateWellOperation(int idWell) =>
new()
{
IdWell = idWell,
IdWellSectionType = 2,
LastUpdateDate = DateTimeOffset.UtcNow,
IdCategory = 5000,
IdPlan = null,
CategoryInfo = "1",
IdType = 0,
DepthStart = 10.0,
DepthEnd = 20.0,
DateStart = new DateTimeOffset(new DateTime(2023, 1, 10), TimeSpan.FromHours(Defaults.Timezone.Hours)).ToUniversalTime(),
DurationHours = 1.0,
Comment = "1",
IdUser = 1
};
} }

254
AsbCloudWebApi.IntegrationTests/Repository/DataSaubStatRepositoryTest.cs
View File

@ -2,6 +2,7 @@
using AsbCloudApp.Repositories; using AsbCloudApp.Repositories;
using AsbCloudDb.Model; using AsbCloudDb.Model;
using Mapster; using Mapster;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Xunit; using Xunit;
@ -9,157 +10,128 @@ namespace AsbCloudWebApi.IntegrationTests.Repository;
public class DataSaubStatRepositoryTest : BaseIntegrationTest public class DataSaubStatRepositoryTest : BaseIntegrationTest
{ {
private static readonly TimeSpan timeSpan = TimeSpan.FromHours(1); private readonly IDataSaubStatRepository dataSaubStatRepository;
public DataSaubStatRepositoryTest(WebAppFactoryFixture factory)
: base(factory)
{
dataSaubStatRepository = scope.ServiceProvider.GetRequiredService<IDataSaubStatRepository>();
dbContext.CleanupDbSet<DataSaubStat>();
}
private static readonly DataSaubStatDto[] statDtos = new DataSaubStatDto[2] [Fact]
{ public async Task GetLastDatesAsync_returns_success()
new() {
{ //arrange
IdTelemetry = 1, var telemetry = await dbContext.Telemetries.FirstAsync();
DateEnd = new DateTimeOffset(2024, 1, 1, 20, 25, 0, timeSpan), var timeZoneOffset = TimeSpan.FromHours(telemetry.TimeZone.Hours);
DateStart = new DateTimeOffset(2024, 1, 1, 20, 15, 0, timeSpan), var dataSaubStat = CreateDataSaubStat(telemetry.Id, timeZoneOffset);
AxialLoad = 10.0, dbContext.AddRange(dataSaubStat);
AxialLoadLimitMax = 10.0, await dbContext.SaveChangesAsync();
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
Id = default,
IdCategory = 2,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 9.0,
RotorTorque = 9.0,
RotorTorqueSp = 9.0,
RotorTorqueLimitMax = 9.0,
Speed = 10.0
},
new()
{
IdTelemetry = 1,
DateEnd = new DateTimeOffset(2024, 2, 2, 20, 25, 0, timeSpan),
DateStart = new DateTimeOffset(2024, 2, 2, 20, 15, 0, timeSpan),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
Id = default,
IdCategory = 2,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 10.0,
RotorTorque = 10.0,
RotorTorqueSp = 10.0,
RotorTorqueLimitMax = 10.0,
Speed = 10.0
}
};
private static readonly WellOperationCategory category = new()
{
Id = 2,
IdParent = null,
Name = "Категория 2"
};
private readonly IDataSaubStatRepository dataSaubStatRepository; var telemetryIds = dataSaubStat.Select(stat => stat.IdTelemetry).ToArray();
public DataSaubStatRepositoryTest(WebAppFactoryFixture factory) : base(factory) //act
{ var result = await dataSaubStatRepository.GetLastsAsync(telemetryIds, CancellationToken.None);
dataSaubStatRepository = scope.ServiceProvider.GetRequiredService<IDataSaubStatRepository>();
}
[Fact] //assert
public async Task GetLastDatesAsync_returns_success() var expected = dataSaubStat.Max(stat => stat.DateEnd).ToOffset(timeZoneOffset);
{ var actual = result.First().DateEnd;
//prepare Assert.True((expected - actual).Ticks == 0.0);
dbContext.CleanupDbSet<DataSaubStat>(); }
dbContext.CleanupDbSet<WellOperationCategory>();
var dbSetSaubStat = dbContext.Set<DataSaubStat>(); [Fact]
var dbSetCategories = dbContext.Set<WellOperationCategory>(); public async Task InsertRangeAsync_returns_success()
{
//arrange
var telemetry = await dbContext.Telemetries.FirstAsync();
var timeZoneOffset = TimeSpan.FromHours(telemetry.TimeZone.Hours);
var dataSaubStat = CreateDataSaubStat(telemetry.Id, timeZoneOffset);
var expectedDtos = dataSaubStat.Select(entity => ConvertToDto(entity, timeZoneOffset));
var entities = statDtos.Select(stat => ConvertToEntity(stat)); //act
await dataSaubStatRepository.InsertRangeAsync(expectedDtos, CancellationToken.None);
dbSetCategories.Add(category); //assert
dbContext.SaveChanges(); var entities = await dbContext.DataSaubStat.ToArrayAsync();
var actualDtos = entities.Select(entity => ConvertToDto(entity, timeZoneOffset));
dbSetSaubStat.AddRange(entities); var excludedProps = new[]
dbContext.SaveChanges(); {
nameof(DataSaubStat.Telemetry),
nameof(DataSaubStat.Id),
nameof(DataSaubStat.OperationCategory)
};
//act foreach (var actualDto in actualDtos)
var telemetryIds = statDtos.Select(stat => stat.IdTelemetry).ToArray(); {
var result = await dataSaubStatRepository.GetLastsAsync(telemetryIds, CancellationToken.None); var statDto = expectedDtos.FirstOrDefault(stat => stat.DateEnd == actualDto.DateEnd &&
stat.DateStart == actualDto.DateStart);
var expected = statDtos.Max(stat => stat.DateEnd); MatchHelper.Match(actualDto, statDto, excludedProps);
var actual = result.First().DateEnd; }
}
//assert private static IEnumerable<DataSaubStat> CreateDataSaubStat(int idTelemetry, TimeSpan timeZoneOffset) => new DataSaubStat[]
Assert.True((expected - actual).Ticks == 0.0); {
} new()
{
IdTelemetry = idTelemetry,
DateEnd = new DateTimeOffset(2024, 1, 1, 20, 25, 0, timeZoneOffset).ToUniversalTime(),
DateStart = new DateTimeOffset(2024, 1, 1, 20, 15, 0, timeZoneOffset).ToUniversalTime(),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
IdCategory = WellOperationCategory.IdSlide,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 9.0,
RotorTorque = 9.0,
RotorTorqueSp = 9.0,
RotorTorqueLimitMax = 9.0,
Speed = 10.0
},
new()
{
IdTelemetry = idTelemetry,
DateEnd = new DateTimeOffset(2024, 2, 2, 20, 25, 0, timeZoneOffset).ToUniversalTime(),
DateStart = new DateTimeOffset(2024, 2, 2, 20, 15, 0, timeZoneOffset).ToUniversalTime(),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
IdCategory = WellOperationCategory.IdSlide,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 10.0,
RotorTorque = 10.0,
RotorTorqueSp = 10.0,
RotorTorqueLimitMax = 10.0,
Speed = 10.0
}
};
[Fact] private static DataSaubStatDto ConvertToDto(DataSaubStat entity, TimeSpan timeZoneOffset)
public async Task InsertRangeAsync_returns_success() {
{ var dto = entity.Adapt<DataSaubStatDto>();
//prepare dto.DateStart = dto.DateStart.ToOffset(timeZoneOffset);
dbContext.CleanupDbSet<DataSaubStat>(); dto.DateEnd = dto.DateEnd.ToOffset(timeZoneOffset);
var dbSet = dbContext.Set<DataSaubStat>();
var dbSetCategories = dbContext.Set<WellOperationCategory>();
dbSetCategories.Add(category);
dbContext.SaveChanges(); return dto;
}
//act }
var result = await dataSaubStatRepository.InsertRangeAsync(statDtos, CancellationToken.None);
//assert
Assert.Equal(statDtos.Length, result);
var statDtosFromDb = dbSet.Select(stat => ConvertToDto(stat, timeSpan)).ToArray();
var excludedProps = new[] {
nameof(DataSaubStat.Telemetry),
nameof(DataSaubStat.Id),
nameof(DataSaubStat.OperationCategory)
};
foreach (var statDtoFromDb in statDtosFromDb)
{
var statDto = statDtos
.Where(stat => stat.DateStart == statDtoFromDb.DateStart)
.Where(stat => stat.DateEnd == statDtoFromDb.DateEnd)
.FirstOrDefault();
MatchHelper.Match(statDtoFromDb, statDto, excludedProps);
}
}
private static DataSaubStat ConvertToEntity(DataSaubStatDto stat)
{
var entity = stat.Adapt<DataSaubStat>();
entity.DateStart = entity.DateStart.ToUniversalTime();
entity.DateEnd = entity.DateEnd.ToUniversalTime();
return entity;
}
private static DataSaubStatDto ConvertToDto(DataSaubStat stat, TimeSpan timeSpan)
{
var dto = stat.Adapt<DataSaubStatDto>();
dto.DateStart = dto.DateStart.ToOffset(timeSpan);
dto.DateEnd = dto.DateEnd.ToOffset(timeSpan);
return dto;
}
}