microting/eform-sdk-dotnet

View on GitHub
eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs

Summary

Maintainability
F
1 mo
Test Coverage

File CoreTesteFormCreateInDB.cs has 2047 lines of code (exceeds 250 allowed). Consider refactoring.
Open

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
Severity: Major
Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 5 days to fix

    Method Core_eForm_OptionsWithMicrotingFormCreateInDB_ReturnseFormId has 472 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

            [Test]
            public async Task Core_eForm_OptionsWithMicrotingFormCreateInDB_ReturnseFormId()
            {
                // Arrange
                string xmlstring = @"
    Severity: Major
    Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 days to fix

      Method Core_eForm_MultiLvleFormCreateInDB_ReturnseFormId has 159 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              [Test]
              public async Task Core_eForm_MultiLvleFormCreateInDB_ReturnseFormId()
              {
                  // Arrange
                  string xmlstring = @"
      Severity: Major
      Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 6 hrs to fix

        Method Core_eFormSimpleSingleSelectFormCreateInDB_ReturnseFormId has 146 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                [Test]
                public async Task Core_eFormSimpleSingleSelectFormCreateInDB_ReturnseFormId()
                {
                    string xmlstring = @"
                        <?xml version='1.0' encoding='UTF-8'?>
        Severity: Major
        Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 5 hrs to fix

          Method Core_eForm_SimpleMultiSelectFormCreateInDB_ReturnseFormId has 144 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  [Test]
                  public async Task Core_eForm_SimpleMultiSelectFormCreateInDB_ReturnseFormId()
                  {
                      // Arrange
                      string xmlstring = @"
          Severity: Major
          Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 5 hrs to fix

            Method Core_eForm_SimpleFieldGroupsFormCreateInDB_ReturnseFormId has 116 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    [Test]
                    public async Task Core_eForm_SimpleFieldGroupsFormCreateInDB_ReturnseFormId()
                    {
                        // Arrange
                        string xmlstring = @"
            Severity: Major
            Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 4 hrs to fix

              Method Core_eForm_SimplePictureAndSignatureFormCreateInDB_ReturnseFormId has 82 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                      [Test]
                      public async Task Core_eForm_SimplePictureAndSignatureFormCreateInDB_ReturnseFormId()
                      {
                          // Arrange
                          string xmlstring = @"
              Severity: Major
              Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 3 hrs to fix

                Method Core_eFormSimpleNumberFormCreateInDB_ReturnseFormId has 79 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                        [Test]
                        public async Task Core_eFormSimpleNumberFormCreateInDB_ReturnseFormId()
                        {
                            string xmlstring = @"
                                <?xml version='1.0' encoding='UTF-8'?>
                Severity: Major
                Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 3 hrs to fix

                  Method Core_eForm_SimpleCommenteFormCreateInDB_ReturnseFormId has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                          [Test] // Core_Template_TemplateFromXml_ReturnsTemplate()
                          public async Task Core_eForm_SimpleCommenteFormCreateInDB_ReturnseFormId()
                          {
                              // Arrange
                              string xmlstring = @"
                  Severity: Major
                  Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 3 hrs to fix

                    Method Core_eFormSimpleTextSingleLineFormCreateInDB_ReturnseFormId has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                            [Test] // Text
                            public async Task Core_eFormSimpleTextSingleLineFormCreateInDB_ReturnseFormId()
                            {
                                string xmlstring = @"
                                    <?xml version='1.0' encoding='UTF-8'?>
                    Severity: Major
                    Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 3 hrs to fix

                      Method Core_eFormSimpleTextMultiLineFormCreateInDB_ReturnseFormId has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                              [Test] // Comment
                              public async Task Core_eFormSimpleTextMultiLineFormCreateInDB_ReturnseFormId()
                              {
                                  string xmlstring = @"
                                      <?xml version='1.0' encoding='UTF-8'?>
                      Severity: Major
                      Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 3 hrs to fix

                        Method Core_eForm_SimpleDateFormCreateInDB_ReturnseFormId has 74 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                                [Test]
                                public async Task Core_eForm_SimpleDateFormCreateInDB_ReturnseFormId()
                                {
                                    // Arrange
                                    string xmlstring = @"
                        Severity: Major
                        Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                          Method Core_eFormSimpleCheckBoxFormCreateInDB_ReturnseFormId has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                                  [Test]
                                  public async Task Core_eFormSimpleCheckBoxFormCreateInDB_ReturnseFormId()
                                  {
                                      string xmlstring = @"
                                          <?xml version='1.0' encoding='UTF-8'?>
                          Severity: Major
                          Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                            Method Core_eForm_SimplePdfFormCreateInDB_ReturnseFormId has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                    [Test]
                                    public async Task Core_eForm_SimplePdfFormCreateInDB_ReturnseFormId()
                                    {
                                        // Arrange
                                        string xmlstring = @"
                            Severity: Major
                            Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                              Method Core_eFormSimpleTimerFormCreateInDB_ReturnseFormId has 70 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                      [Test]
                                      public async Task Core_eFormSimpleTimerFormCreateInDB_ReturnseFormId()
                                      {
                                          string xmlstring = @"
                                              <?xml version='1.0' encoding='UTF-8'?>
                              Severity: Major
                              Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                                Method Core_eForm_SimplePictureFormCreateInDB_ReturnseFormId has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                        [Test]
                                        public async Task Core_eForm_SimplePictureFormCreateInDB_ReturnseFormId()
                                        {
                                            // Arrange
                                            string xmlstring = @"
                                Severity: Major
                                Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                                  Method Core_eFormSimpleSaveButtonFormCreateInDB_ReturnseFormId has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                          [Test]
                                          public async Task Core_eFormSimpleSaveButtonFormCreateInDB_ReturnseFormId()
                                          {
                                              string xmlstring = @"
                                                  <?xml version='1.0' encoding='UTF-8'?>
                                  Severity: Major
                                  Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                                    Method Core_eFormSimpleInfoboxFormCreateInDB_ReturnseFormId has 67 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                            [Test]
                                            public async Task Core_eFormSimpleInfoboxFormCreateInDB_ReturnseFormId()
                                            {
                                                string xmlstring = @"
                                                    <?xml version='1.0' encoding='UTF-8'?>
                                    Severity: Major
                                    Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                                      Class CoreTesteFormCreateInDB has 24 methods (exceeds 20 allowed). Consider refactoring.
                                      Open

                                          [Parallelizable(ParallelScope.Fixtures)]
                                          [TestFixture]
                                          public class CoreTesteFormCreateInDB : DbTestFixture
                                          {
                                              private Core sut;
                                      Severity: Minor
                                      Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs - About 2 hrs to fix

                                        Method DoSetup has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                                public override async Task DoSetup()
                                                {
                                                    #region Setup SettingsTableContent
                                        
                                                    DbContextHelper dbContextHelper = new DbContextHelper(ConnectionString);

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test] // Comment
                                                  public async Task Core_eFormSimpleTextMultiLineFormCreateInDB_ReturnseFormId()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 1732..1827

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 1040.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test] // Text
                                                  public async Task Core_eFormSimpleTextSingleLineFormCreateInDB_ReturnseFormId()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 1636..1730

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 1040.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eFormSimpleCheckBoxFormCreateInDB_ReturnseFormId()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 271..365

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 968.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eForm_SimpleDateFormCreateInDB_ReturnseFormId()
                                                  {
                                                      // Arrange
                                                      string xmlstring = @"
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 2010..2096

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 968.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eFormSimpleTimerFormCreateInDB_ReturnseFormId()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 184..269

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 932.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eForm_SimplePictureFormCreateInDB_ReturnseFormId()
                                                  {
                                                      // Arrange
                                                      string xmlstring = @"
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 2098..2184

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 932.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eFormSimpleSaveButtonFormCreateInDB_ReturnseFormId()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 1926..2008

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 896.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eFormSimpleInfoboxFormCreateInDB_ReturnseFormId()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormCreateInDB.cs on lines 2186..2270

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 896.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          There are no issues that match your filters.

                                          Category
                                          Status