Sign upLogin

cyberark/secretless-broker

View on GitHub
Star

Showing 1,856 of 1,876 total issues

Function TestSSL has 215 lines of code (exceeds 70 allowed). Consider refactoring.
Open

func TestSSL(t *testing.T) {

    testCases := []TestCase{
        {
            Definition: Definition{
Severity: Major
Found in test/connector/tcp/pg/tests/ssl_test.go - About 6 hrs to fix

    Function TestSSL has 212 lines of code (exceeds 70 allowed). Consider refactoring.
    Open

    func TestSSL(t *testing.T) {

    testCases := []TestCase{
        {
            Definition: Definition{
    Severity: Major
    Found in test/connector/tcp/mysql/tests/ssl_test.go - About 6 hrs to fix

      Method ServiceConnector.Connect has a Cognitive Complexity of 58 (exceeds 20 allowed). Consider refactoring.
      Open

      func (h *ServiceConnector) Connect(
    credentialValuesByID connector.CredentialValuesByID,
) error {
    var err error
    var serverConfig ServerConfig
      Severity: Minor
      Found in internal/plugin/connectors/ssh/service_connector.go - About 6 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      File protocol.go has 651 lines of code (exceeds 500 allowed). Consider refactoring.
      Open

      /*
MIT License

Copyright (c) 2017 Aleksandr Fedotov
      Severity: Minor
      Found in internal/plugin/connectors/tcp/mysql/protocol/protocol.go - About 5 hrs to fix

        Function TestProxyService_Start has 178 lines of code (exceeds 70 allowed). Consider refactoring.
        Open

        func TestProxyService_Start(t *testing.T) {
    t.Run("stopped proxy service cannot be restarted", func(t *testing.T) {
        connector := mock.NewConnector()
        credentialRetriever := mock.NewCredentialRetriever()
        listener := mock.NewListener()
        Severity: Major
        Found in internal/plugin/connectors/tcp/proxy_service_test.go - About 5 hrs to fix

          Function Test_Config has 165 lines of code (exceeds 70 allowed). Consider refactoring.
          Open

          func Test_Config(t *testing.T) {
    t.Run("Reports absence of handlers", func(t *testing.T) {
        yaml := `
---
`
          Severity: Major
          Found in pkg/secretless/config/config_test.go - About 4 hrs to fix

            Function GenerateConfigurations has a Cognitive Complexity of 45 (exceeds 20 allowed). Consider refactoring.
            Open

            func GenerateConfigurations() (config_v2.Config, LiveConfigurations) {
    // initialised with health-check listener and handler
    secretlessConfig := config_v2.Config{
        Services: []*config_v2.Service{
            {
            Severity: Minor
            Found in test/util/testutil/config_generator.go - About 4 hrs to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

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

                    {
            []byte{
                0x4a, 0x00, 0x00, 0x00, 0x0a, 0x35, 0x2e, 0x35, 0x2e, 0x35, 0x36, 0x00, 0x5e, 0x06, 0x00, 0x00,
                0x48, 0x6a, 0x5b, 0x6a, 0x24, 0x71, 0x30, 0x3a, 0x00, 0xff, 0xf7, 0x08, 0x02, 0x00, 0x0f, 0x80,
                0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0x43, 0x40, 0x56, 0x6e,
            Severity: Major
            Found in internal/plugin/connectors/tcp/mysql/protocol/protocol_test.go and 1 other location - About 3 hrs to fix
            internal/plugin/connectors/tcp/mysql/protocol/protocol_test.go on lines 143..170

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

            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

                    {
            []byte{
                0x4a, 0x00, 0x00, 0x00, 0x0a, 0x35, 0x2e, 0x37, 0x2e, 0x31, 0x38, 0x00, 0x0f, 0x00, 0x00, 0x00,
                0x15, 0x12, 0x4b, 0x1f, 0x70, 0x2b, 0x33, 0x55, 0x00, 0xff, 0xff, 0x08, 0x02, 0x00, 0xff, 0xc1,
                0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x0d, 0x0a, 0x28,
            Severity: Major
            Found in internal/plugin/connectors/tcp/mysql/protocol/protocol_test.go and 1 other location - About 3 hrs to fix
            internal/plugin/connectors/tcp/mysql/protocol/protocol_test.go on lines 115..142

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

            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

            Function TestAllAvailablePlugins has 140 lines of code (exceeds 70 allowed). Consider refactoring.
            Open

            func TestAllAvailablePlugins(t *testing.T) {
    t.Run("Assembles internal and external plugins", func(t *testing.T) {
        allPlugins, err := AllAvailablePluginsWithOptions(
            "",
            "",
            Severity: Major
            Found in pkg/secretless/plugin/sharedobj/available_plugins_test.go - About 3 hrs to fix

              Function GenerateConfigurations has 127 lines of code (exceeds 70 allowed). Consider refactoring.
              Open

              func GenerateConfigurations() (config_v2.Config, LiveConfigurations) {
    // initialised with health-check listener and handler
    secretlessConfig := config_v2.Config{
        Services: []*config_v2.Service{
            {
              Severity: Major
              Found in test/util/testutil/config_generator.go - About 3 hrs to fix

                Method AuthenticationHandshake.handleBackendAuthResponse has a Cognitive Complexity of 38 (exceeds 20 allowed). Consider refactoring.
                Open

                func (h *AuthenticationHandshake) handleBackendAuthResponse() {
    if h.err != nil {
        return
    }
                Severity: Minor
                Found in internal/plugin/connectors/tcp/mysql/authentication_handshake.go - About 3 hrs to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Cyclomatic complexity is too high in function process_log. (14)
                Open

                def process_log(logfile_path, baseline_backend):
    percentages = {}
    baselines = []
    with open(logfile_path) as log_file:
        for line in log_file:
                Severity: Minor
                Found in bin/juxtaposer/aggregate.py by radon

                Cyclomatic Complexity

                Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

                Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

                Construct Effect on CC Reasoning
                if +1 An if statement is a single decision.
                elif +1 The elif statement adds another decision.
                else +0 The else statement does not cause a new decision. The decision is at the if.
                for +1 There is a decision at the start of the loop.
                while +1 There is a decision at the while statement.
                except +1 Each except branch adds a new conditional path of execution.
                finally +0 The finally block is unconditionally executed.
                with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
                assert +1 The assert statement internally roughly equals a conditional statement.
                Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
                Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

                Source: http://radon.readthedocs.org/en/latest/intro.html

                Function Test_Health has 124 lines of code (exceeds 70 allowed). Consider refactoring.
                Open

                func Test_Health(t *testing.T) {
    t.Run("When nothing is proactively done", func(t *testing.T) {
        t.Run("Shows not ready", func(t *testing.T) {
            callEnableHealthCheck()
            assertHealthStatusCodeIsBad(ReadyEndpoint, t)
                Severity: Major
                Found in internal/util/health_test.go - About 3 hrs to fix

                  Logger has 25 methods (exceeds 20 allowed). Consider refactoring.
                  Open

                  type Logger struct {
    BackingLogger *stdlib_log.Logger
    IsDebug       bool
    prefix        string
}
                  Severity: Minor
                  Found in internal/log/log.go - About 2 hrs to fix

                    Function TestConfigEnv has 115 lines of code (exceeds 70 allowed). Consider refactoring.
                    Open

                    func TestConfigEnv(t *testing.T) {

    // Shared mocks and doubles

    logger := loggermock.NewLogger()
                    Severity: Major
                    Found in pkg/secretless/config/v2/config_env_test.go - About 2 hrs to fix

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

                      func TestGetStandardDeviation(t *testing.T) {
    t.Run("nil input", func(t *testing.T) {
        input := &map[int]int{}
        res := GetStandardDeviation(input)
                      Severity: Major
                      Found in bin/juxtaposer/formatter/util/util_test.go and 1 other location - About 2 hrs to fix
                      bin/juxtaposer/formatter/util/util_test.go on lines 40..66

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

                      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

                      func TestGetMean(t *testing.T) {
    t.Run("nil input", func(t *testing.T) {
        input := &map[int]int{}
        res := GetMean(input)
                      Severity: Major
                      Found in bin/juxtaposer/formatter/util/util_test.go and 1 other location - About 2 hrs to fix
                      bin/juxtaposer/formatter/util/util_test.go on lines 12..38

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

                      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

                      File protocol_test.go has 531 lines of code (exceeds 500 allowed). Consider refactoring.
                      Open

                      /*
MIT License

Copyright (c) 2017 Aleksandr Fedotov
                      Severity: Minor
                      Found in internal/plugin/connectors/tcp/mysql/protocol/protocol_test.go - About 2 hrs to fix

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

                        package pg

import (
    "net"
                        Severity: Major
                        Found in internal/plugin/connectors/tcp/pg/plugin.go and 1 other location - About 2 hrs to fix
                        internal/plugin/connectors/tcp/mysql/plugin.go on lines 1..48

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

                        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

                        Severity
                        Category
                        Status
                        Source
                        Language