Пример #1
0
        public IActionResult UpdateApprovalType([FromBody] ApprovalType approvalType)
        {
            try
            {
                if (approvalType == null)
                {
                    return(Ok(new APIResponse()
                    {
                        status = APIStatus.FAIL.ToString(), response = $"{nameof(approvalType)} cannot be null"
                    }));
                }

                ApprovalType result = ApprovalHelper.UpdateApprovalType(approvalType);
                if (result != null)
                {
                    return(Ok(new APIResponse()
                    {
                        status = APIStatus.PASS.ToString(), response = result
                    }));
                }

                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = "Updation Failed."
                }));
            }
            catch (Exception ex)
            {
                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = ex.Message
                }));
            }
        }
Пример #2
0
 public IActionResult GeApprovalTypeList()
 {
     try
     {
         var approvalTypeList = ApprovalHelper.GetListOfApprovals();
         if (approvalTypeList.Count > 0)
         {
             dynamic expando = new ExpandoObject();
             expando.approvalTypeList = approvalTypeList;
             return(Ok(new APIResponse()
             {
                 status = APIStatus.PASS.ToString(), response = expando
             }));
         }
         return(Ok(new APIResponse()
         {
             status = APIStatus.FAIL.ToString(), response = "No Data Found."
         }));
     }
     catch (Exception ex)
     {
         return(Ok(new APIResponse()
         {
             status = APIStatus.FAIL.ToString(), response = ex.Message
         }));
     }
 }
Пример #3
0
        public IActionResult DeleteApprovalType(int approvalId)
        {
            try
            {
                ApprovalType result = ApprovalHelper.DeleteApprovalType(approvalId);
                if (result != null)
                {
                    return(Ok(new APIResponse()
                    {
                        status = APIStatus.PASS.ToString(), response = result
                    }));
                }

                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = "Deletion Failed."
                }));
            }
            catch (Exception ex)
            {
                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = ex.Message
                }));
            }
        }
Пример #4
0
        public IActionResult RegisterApprovalType([FromBody] ApprovalType approvalType)
        {
            if (approvalType == null)
            {
                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = "Request cannot be null"
                }));
            }
            try
            {
                ApprovalType result = ApprovalHelper.RegisterApprovalType(approvalType);
                if (result != null)
                {
                    return(Ok(new APIResponse()
                    {
                        status = APIStatus.PASS.ToString(), response = result
                    }));
                }

                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = "Registration Failed."
                }));
            }
            catch (Exception ex)
            {
                return(Ok(new APIResponse()
                {
                    status = APIStatus.FAIL.ToString(), response = ex.Message
                }));
            }
        }
Пример #5
0
        public void Execute()
        {
            var rootDirectory    = SolutionDir.GetRootPath();
            var sampleDirectory  = Path.Combine(rootDirectory, "sample");
            var miniCoverPath    = Path.Combine(rootDirectory, "src/MiniCover");
            var toolPath         = Path.Combine(sampleDirectory, "tools");
            var minicoverWorkdir = Path.Combine(sampleDirectory, "coverage");

            if (Directory.Exists(minicoverWorkdir))
            {
                Directory.Delete(minicoverWorkdir, true);
            }

            var result = Command.CreateDotNet("restore", new[] { "--no-cache" })
                         .WorkingDirectory(sampleDirectory)
                         .CaptureStdOut()
                         .CaptureStdErr()
                         .Execute();

            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("clean", new string[0])
                     .WorkingDirectory(sampleDirectory)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("build", new[] { "--no-restore" })
                     .WorkingDirectory(sampleDirectory)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "instrument", "--workdir", minicoverWorkdir, "--parentdir", "../", "--assemblies", "**/bin/**/*.dll", "--sources", "**/*.cs" })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "reset", "--workdir", minicoverWorkdir })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            var testProjects = Directory.EnumerateFiles(Path.Combine(sampleDirectory, "test"), "*.csproj",
                                                        SearchOption.AllDirectories);

            foreach (var testProject in testProjects.OrderBy(a => new FileInfo(a).Name))
            {
                result = Command.CreateDotNet("test", new[] { testProject, "--no-build" })
                         .WorkingDirectory(sampleDirectory)
                         .CaptureStdOut()
                         .CaptureStdErr()
                         .Execute();
                result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
                result.StdErr.ShouldBeNullOrEmpty();
            }

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "uninstrument", "--workdir", minicoverWorkdir })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            var coverageJson = StringConverger.ApplyCleanup(File.ReadAllText(Path.Combine(minicoverWorkdir, "coverage.json")), new Uri(sampleDirectory).LocalPath);

            ApprovalHelper.VerifyText(coverageJson, "coverage", "json");

            var coverageHits = File.ReadAllBytes(Path.Combine(minicoverWorkdir, "coverage.hits"));

            ApprovalHelper.VerifyByte(coverageHits, "coverage", "hits");

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "report", "--workdir", minicoverWorkdir, "--threshold", "80" })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "htmlreport", "--workdir", minicoverWorkdir, "--threshold", "80" })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "xmlreport", "--workdir", minicoverWorkdir, "--threshold", "80" })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "opencoverreport", "--workdir", minicoverWorkdir, "--threshold", "80" })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();

            result = Command.CreateDotNet("run", new[] { "--no-build", "--", "cloverreport", "--workdir", minicoverWorkdir, "--threshold", "80" })
                     .WorkingDirectory(miniCoverPath)
                     .CaptureStdOut()
                     .CaptureStdErr()
                     .Execute();
            result.ExitCode.ShouldBe(0, $"output:{result.StdOut}{Environment.NewLine}errors:{result.StdErr}");
            result.StdErr.ShouldBeNullOrEmpty();
        }