microting/eform-sdk-dotnet

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

Summary

Maintainability
F
3 wks
Test Coverage

File CoreTesteFormFromXML.cs has 1904 lines of code (exceeds 250 allowed). Consider refactoring.
Open

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

    Method Core_eForm_OptionsWithMicrotingFormFromXML_ReturnseMainElement has 452 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

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

      Method Core_eForm_MultiLvleFormFromXML_ReturnseMainElement has 153 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

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

        Method Core_eFormSimpleSingleSelectFormFromXML_ReturnseMainElement has 143 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

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

          Method Core_eForm_SimpleMultiSelectFormFromXML_ReturnseMainElement has 134 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

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

            Method Core_eForm_SimpleFieldGroupsFormFromXML_ReturnseMainElement has 110 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

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

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

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

                Method Core_eForm_SimpleCommenteFormFromXML_ReturnseMainElement has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

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

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

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

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

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

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

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

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

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

                          Method Core_eForm_SimpleDateFormFromXML_ReturnseMainElement has 66 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

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

                            Method Core_eFormSimpleTimerFormFromXML_ReturnseMainElement has 63 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

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

                              Method Core_eForm_SimplePdfFormFromXML_ReturnseMainElement has 63 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

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

                                Method Core_eFormSimpleCheckBoxFormFromXML_ReturnseMainElement has 63 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

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

                                  Method Core_eForm_SimplePictureFormFromXML_ReturnseMainElement has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

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

                                    Method Core_eFormSimpleSaveButtonFormFromXML_ReturnseMainElement has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

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

                                      Method Core_eFormSimpleInfoboxFormFromXML_ReturnseMainElement has 59 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                              [Test]
                                              public async Task Core_eFormSimpleInfoboxFormFromXML_ReturnseMainElement()
                                              {
                                                  string xmlstring = @"
                                                      <?xml version='1.0' encoding='UTF-8'?>
                                      Severity: Major
                                      Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.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);
                                        Severity: Minor
                                        Found in eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs - About 1 hr to fix

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

                                                  [Test]
                                                  public async Task Core_eFormSimpleCheckBoxFormFromXML_ReturnseMainElement()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 251..336
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 1962..2042

                                          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 658.

                                          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 3 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eFormSimpleTimerFormFromXML_ReturnseMainElement()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 251..336
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 1880..1960

                                          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 658.

                                          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 3 locations. Consider refactoring.
                                          Open

                                                  [Test]
                                                  public async Task Core_eForm_SimpleDateFormFromXML_ReturnseMainElement()
                                                  {
                                                      // Arrange
                                                      string xmlstring = @"
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 1880..1960
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 1962..2042

                                          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 658.

                                          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_eFormSimpleSaveButtonFormFromXML_ReturnseMainElement()
                                                  {
                                                      string xmlstring = @"
                                                          <?xml version='1.0' encoding='UTF-8'?>
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 171..249

                                          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 629.

                                          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_SimplePictureFormFromXML_ReturnseMainElement()
                                                  {
                                                      // Arrange
                                                      string xmlstring = @"
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormFromXML.cs on lines 2044..2122

                                          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 629.

                                          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

                                          Identical blocks of code found in 4 locations. Consider refactoring.
                                          Open

                                                  public override async Task DoSetup()
                                                  {
                                                      #region Setup SettingsTableContent
                                          
                                                      DbContextHelper dbContextHelper = new DbContextHelper(ConnectionString);
                                          eFormSDK.Integration.Base.CoreTests/CoreTestEntity.cs on lines 53..83
                                          eFormSDK.Integration.Base.CoreTests/CoreTestTag.cs on lines 53..83
                                          eFormSDK.Integration.CheckLists.CoreTests/CoreTesteFormQuickSyncXML.cs on lines 51..81

                                          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 390.

                                          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