tests/AppRemoteConfigTests/Controllers/ApplicationControllerTests.cs - trunk - qwiklly/arc-server

tests/AppRemoteConfigTests/Controllers/ApplicationControllerTests.cs
290 строк12 KB
CLTanuki
feat(#8): string flags allowed
02 янв 2024, 19:01
02 янв 2024, 19:01e674a83
namespace AppRemoteConfigTests.Controllers
{
    using AppRemoteConfig.Controllers;
    using AppRemoteConfig.Helpers;
    using AppRemoteConfig.Models;
    using AppRemoteConfig.Models.Database;
    using AppRemoteConfig.Models.Dto;
    using AppRemoteConfigTests.Fixtures;
    using EdjCase.JsonRpc.Router.Defaults;
    using Microsoft.AspNetCore.Http;
    using Microsoft.Extensions.Logging;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Moq;

    [TestClass()]
    public class ApplicationControllerTests
    {
        private readonly Mock<IHttpContextAccessor> _mockHttpContextAccessor;
        private readonly Mock<ILogger<ApplicationController>> _mockLogger;
        private readonly Mock<ApplicationContext> _mockContext;

        public ApplicationControllerTests()
        {
            _mockContext = TestMockSetup.GetContextMock();

            _mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
            var httpContext = new DefaultHttpContext();
            _mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(httpContext);

            _mockLogger = new Mock<ILogger<ApplicationController>>();
        }

        [TestMethod()]
        public async Task GetApplication()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);

            var app = await controller.GetApplication(_mockContext.Object.Applications.First().Id);

            Assert.IsNotNull(app);
            Assert.AreEqual(_mockContext.Object.Applications.First().Title, app.Title);
            Assert.AreEqual(_mockContext.Object.Applications.First().OrganizationId, app.OrganizationId);
        }

        [TestMethod()]
        public async Task GetAllApplicationsWithoutArchived()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);

            var apps = await controller.ListApplications();

            Assert.AreEqual(1, apps.Count());
        }

        [TestMethod()]
        public async Task GetAllApplicationsWithArchived()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);

            var apps = await controller.ListApplications(true);

            Assert.AreEqual(2, apps.Count());
        }

        [TestMethod()]
        public async Task CreateApplication()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var orgId = _mockContext.Object.Organizations.First().Id;
            var appCreateRequest = new AppCreateRequest()
            { 
                Title = "App 3", 
                Description = "Description app 3", 
                OrganizationId = orgId 
            };

            var addedAppDto = await controller.CreateApplication(appCreateRequest);

            var addedApp = _mockContext.Object.Applications.FirstOrDefault(a => a.Title == "App 3");
            Assert.IsNotNull(addedAppDto);
            Assert.IsNotNull(addedApp);
            Assert.AreEqual("Description app 3", addedApp.Description); ;
            Assert.AreEqual(orgId, addedApp.Organization.Id);
            Assert.AreEqual(3, _mockContext.Object.Applications.Count());
            _mockContext.Verify(m => m.SaveChangesAsync(default), Times.Once);
        }

        [TestMethod()]
        public async Task UpdateApplication()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var app = _mockContext.Object.Applications.Single(app => app.Title == "App 2");

            app.Description = "New Description app 2";
            var updatedApp = await controller.PutApplication(app);

            Assert.IsNotNull(updatedApp);
            Assert.AreEqual("New Description app 2", updatedApp.Description);
            _mockContext.Verify(m => m.SaveChangesAsync(default), Times.Once);
        }

        [TestMethod()]
        public async Task DeleteApplication()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var appId = _mockContext.Object.Applications.First().Id;

            var result = await controller.DeleteApplication(appId);

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(RpcMethodSuccessResult));            
            Assert.AreEqual(1, _mockContext.Object.Applications.Count());
        }

        [TestMethod()]
        public async Task GetApplicationVersion()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var versionId = _mockContext.Object.Versions.First(version => version.Minor == 1).Id;

            var appVersion = await controller.GetApplicationVersion(versionId);

            Assert.IsNotNull(appVersion);
            Assert.AreEqual("Version 1.1.0", appVersion.Description);
        }

        [TestMethod()]
        public async Task GetAllApplicationVersions()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);

            var appVersions = await controller.ListApplicationVersions();

            Assert.IsNotNull(appVersions);
            Assert.AreEqual(2, appVersions.Count());
        }

        [TestMethod()]
        public async Task GetAllApplicationVersionsForFirstApp()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var appId = _mockContext.Object.Applications.First(app => app.Title == "App 1").Id;

            var appVersions = await controller.ListApplicationVersions(appId);

            Assert.IsNotNull(appVersions);
            Assert.AreEqual(2, appVersions.Count());
        }

        [TestMethod()]
        public async Task CreateApplicationVersion()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var appId = _mockContext.Object.Applications.First(app => app.Title == "App 2").Id;
            var versionCreateRequest = new AppVersionEntityDto()
            {
                ApplicationId = appId,
                Major = 1,
                Minor = 2,
                Patch = 0
            };

            var addedVersionDto = await controller.CreateApplicationVersion(versionCreateRequest);

            Assert.IsNotNull(addedVersionDto);
            Assert.AreEqual(3, _mockContext.Object.Versions.Count());
            _mockContext.Verify(m => m.SaveChangesAsync(default), Times.Once);
        }

        [TestMethod()]
        public async Task UpdateApplicationVersion()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var app = _mockContext.Object.Applications.Single(app => app.Title == "App 1");
            var version = app.Versions.First(vers => vers.Minor == 1);

            version.Patch = 1;
            var updatedVersion = await controller.PutApplicationVersion(version);

            Assert.IsNotNull(updatedVersion);
            Assert.AreEqual(1, updatedVersion.Patch);
            _mockContext.Verify(m => m.SaveChangesAsync(default), Times.Once);
        }

        [TestMethod()]
        public async Task DeleteApplicationVersion()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var versionId = _mockContext.Object.Versions.First().Id;

            var result = await controller.DeleteApplicationVersion(versionId);

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(RpcMethodSuccessResult));
            Assert.AreEqual(1, _mockContext.Object.Versions.Count());
        }

        [TestMethod()]
        public async Task GetValueFlag()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var flagId = _mockContext.Object.ValueFlags.First(flag => flag.Title == "ValueFlag 1").Id;

            var valueFlag = await controller.GetValueFlag(flagId);

            Assert.IsNotNull(valueFlag);
            Assert.AreEqual("Description ValueFlag 1", valueFlag.Description);
        }

        [TestMethod()]
        public async Task GetAllValueFlags()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);

            var valueFlags = await controller.ListValueFlags();

            Assert.IsNotNull(valueFlags);
            Assert.AreEqual(3, valueFlags.Count());
        }

        [TestMethod()]
        public async Task GetAllValueFlagsForFirstApp()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var appId = _mockContext.Object.Applications.First(app => app.Title == "App 1").Id;

            var valueFlags = await controller.ListApplicationValueFlags(appId);

            Assert.IsNotNull(valueFlags);
            Assert.AreEqual(3, valueFlags.Count());
        }

        [TestMethod()]
        public async Task CreateValueFlag()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var appId = _mockContext.Object.Applications.First(app => app.Title == "App 2").Id;
            var valueFlagCreateDto = new ValueFlagEntityDto()
            {
                ApplicableVersionIds = Array.Empty<Guid>(),
                ApplicationId = appId,
                Title = "ValueFlag 4",
                LogicalOperand = LogicalOperand.And,
                FeatureKey = "Test",
                Conditions = new Condition[2]
                {
                    new Condition {ParamName = "Test cond 1", ParamValue = "1", RelationType = RelationType.EQ},
                    new Condition {ParamName = "Test cond 2", ParamValue = "2", RelationType = RelationType.EQ}
                }
            };

            var addedFlagDto = await controller.CreateValueFlag(valueFlagCreateDto);

            var addedFlag = _mockContext.Object.ValueFlags.FirstOrDefault(a => a.Title == "ValueFlag 4");
            Assert.IsNotNull(addedFlagDto);
            Assert.AreEqual(4, _mockContext.Object.ValueFlags.Count());
            Assert.IsNotNull(addedFlag);
            Assert.AreEqual("App 2", addedFlag.Application.Title);
            Assert.AreEqual(2, addedFlag.Conditions.FromJson().Length);
            _mockContext.Verify(m => m.SaveChangesAsync(default), Times.Once);
        }

        [TestMethod()]
        public async Task UpdateValueFlag()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var flag = _mockContext.Object.ValueFlags.Single(flag => flag.Title == "ValueFlag 1");

            flag.Description = "New description ValueFlag 1";
            var updatedFlag = await controller.PutValueFlag(Converters.ValueFlagEntityToDto(flag));

            Assert.IsNotNull(updatedFlag);
            Assert.AreEqual("New description ValueFlag 1", updatedFlag.Description);
            _mockContext.Verify(m => m.SaveChangesAsync(default), Times.Once);
        }

        [TestMethod()]
        public async Task DeleteValueFlag()
        {
            var controller = new ApplicationController(_mockLogger.Object, _mockHttpContextAccessor.Object, _mockContext.Object);
            var flagId = _mockContext.Object.ValueFlags.First().Id;

            var result = await controller.DeleteValueFlag(flagId);

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(RpcMethodSuccessResult));
            Assert.AreEqual(2, _mockContext.Object.ValueFlags.Count());
        }
    }
}