Sign upLogin

Katello/katello

View on GitHub
Star

Showing 2,737 of 2,737 total issues

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

  it('should set enabled to true on REPOSITORY_ENABLED', () => {
    expect(reducer(successState, {
      type: types.REPOSITORY_ENABLED,
      repository: {
        contentId,
Severity: Major
Found in webpack/redux/reducers/RedHatRepositories/__tests__/repositorySetRepositories.test.js and 1 other location - About 1 hr to fix
webpack/redux/reducers/RedHatRepositories/__tests__/repositorySetRepositories.test.js on lines 70..79

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

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

  const {
    getAllByLabelText, getByLabelText, getAllByText, getByText, queryByText,
  } =
    renderWithRedux(withCVRoute(<ContentViewFilterDetails
      cvId={1}
Severity: Major
Found in webpack/scenes/ContentViews/Details/Filters/__tests__/ContentViewPackageGroupFilter.test.js and 1 other location - About 1 hr to fix
webpack/scenes/ContentViews/Details/Filters/__tests__/cvErrataIDFilter.test.js on lines 343..349

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

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

        <WizardStep
          name={__('Review')}
          id="mpw-review-step"
          footer={<BulkPackagesReviewFooter />}
          isDisabled={!step4Valid || !packagesResultsPresent}
Severity: Major
Found in webpack/components/extensions/Hosts/BulkActions/BulkPackagesWizard/BulkPackagesWizard.js and 1 other location - About 1 hr to fix
webpack/components/extensions/Hosts/BulkActions/BulkErrataWizard/BulkErrataWizard.js on lines 144..151

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

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

Method create_audit_record has 36 lines of code (exceeds 25 allowed). Consider refactoring.
Open

      def create_audit_record(action)
        audit = case action
                when 'create'
                  Audit.new(
                    auditable_type: self.class,
Severity: Minor
Found in app/models/katello/concerns/content_view_filter_rule_common.rb - About 1 hr to fix

    Method construct_repo_from_params has 36 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        def construct_repo_from_params(repo_params) # rubocop:disable Metrics/AbcSize
      root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                            :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                            :checksum_type, :download_policy, :http_proxy_policy,
                                                            :metadata_expire).to_h.with_indifferent_access)
    Severity: Minor
    Found in app/controllers/katello/api/v2/repositories_controller.rb - About 1 hr to fix

      Method plan has 36 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              def plan(opts = {})
          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: opts[:metadata])

          import = ::Katello::Pulp3::ContentViewVersion::Import.new(
            organization: opts[:organization],
      Severity: Minor
      Found in app/lib/actions/katello/content_view_version/import.rb - About 1 hr to fix

        Function CreateContentViewForm has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

        const CreateContentViewForm = ({ setModalOpen }) => {
  const dispatch = useDispatch();
  const [name, setName] = useState('');
  const [label, setLabel] = useState('');
  const [description, setDescription] = useState('');
        Severity: Minor
        Found in webpack/scenes/ContentViews/Create/CreateContentViewForm.js - About 1 hr 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

        Function BulkPackagesWizard has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

        const BulkPackagesWizard = () => {
  const { modalOpen, setModalClosed: closeModal } = useForemanModal({ id: 'bulk-packages-wizard' });


  const [selectedAction, setSelectedAction] = useState(UPGRADE_ALL);
        Severity: Minor
        Found in webpack/components/extensions/Hosts/BulkActions/BulkPackagesWizard/BulkPackagesWizard.js - About 1 hr 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

        Function CVPublishForm has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

        const CVPublishForm = ({
  description,
  setDescription,
  details: {
    name, composite,
        Severity: Minor
        Found in webpack/scenes/ContentViews/Publish/CVPublishForm.js - About 1 hr 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

        Method check_composite_action_allowed! has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

            def check_composite_action_allowed!(env)
      if composite? && Setting['restrict_composite_view']
        if components.size != content_view_components.size
          fail _("Make sure all the component content views are published before publishing/promoting the composite content view. "\
               "This restriction is optional and can be modified in the Administrator -> Settings -> Content "\
        Severity: Minor
        Found in app/models/katello/content_view.rb - About 1 hr 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

        Function EditModal has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

        const EditModal = ({ akDetails, akId }) => {
  const dispatch = useDispatch();

  const {
    name, description, maxHosts, unlimitedHosts, usageCount,
        Severity: Minor
        Found in webpack/scenes/ActivationKeys/Details/components/EditModal.js - About 1 hr 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

        Method check_cve_attributes has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

                def check_cve_attributes(attrs)
          if attrs[:content_facet_attributes]
            cv_id = attrs[:content_facet_attributes].delete(:content_view_id)
            lce_id = attrs[:content_facet_attributes].delete(:lifecycle_environment_id)
            # Running validations on a host will clear out any existing errors, and then
        Severity: Minor
        Found in app/models/katello/concerns/host_managed_extensions.rb - About 1 hr 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

        Method build_clone has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

            def build_clone(options)
      to_env       = options[:environment]
      version      = options[:version]
      content_view = options[:content_view] || to_env.default_content_view
      to_version   = version || content_view.version(to_env)
        Severity: Minor
        Found in app/models/katello/repository.rb - About 1 hr 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

        Method ping_services_for_capsule has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

              def ping_services_for_capsule(services, capsule_id)
        services ||= self.services(capsule_id)
        result = {}
        services.each { |service| result[service] = {} }
        Severity: Minor
        Found in app/models/katello/ping.rb - About 1 hr 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

        Method index_relation has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

            def index_relation
      query = Product.readable.where(:organization_id => @organization.id)
      query = query.custom if ::Foreman::Cast.to_bool params[:custom]
      query = query.redhat if ::Foreman::Cast.to_bool params[:redhat_only]
      query = query.where(:name => params[:name]) if params[:name]
        Severity: Minor
        Found in app/controllers/katello/api/v2/products_controller.rb - About 1 hr 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

        Method repository_params has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

            def repository_params
      keys = [:download_policy, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
              :upstream_username, :download_concurrency, :metadata_expire,
              {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
              :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
        Severity: Minor
        Found in app/controllers/katello/api/v2/repositories_controller.rb - About 1 hr 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

        Method refresh_distributions has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

              def refresh_distributions
        if repo.docker?
          dist = lookup_distributions(base_path: repo.container_repository_name).first
        else
          dist = lookup_distributions(base_path: repo.relative_path).first
        Severity: Minor
        Found in app/services/katello/pulp3/repository.rb - About 1 hr 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

        Method index has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

            def index
      history = ContentViewVersionExportHistory.readable
      history = history.where(:id => params[:id]) unless params[:id].blank?
      history = history.where(:content_view_version_id => params[:content_view_version_id]) unless params[:content_view_version_id].blank?
      history = history.where(:destination_server => params[:destination_server]) unless params[:destination_server].blank?
        Severity: Minor
        Found in app/controllers/katello/api/v2/content_exports_controller.rb - About 1 hr 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

        Method register_host has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

              def register_host(host, consumer_params, content_view_environments, activation_keys = [])
        new_host = host.new_record?
        unless new_host
          host.save!
          # Keep the kickstart repository ID so the host's Medium isn't unset
        Severity: Minor
        Found in app/services/katello/registration_manager.rb - About 1 hr 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

        Method validate_hosts has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
        Open

              def validate_hosts(hosts, organization, host_name, host_uuid, host_uuid_overridden: false)
        return if hosts.empty?

        hosts = hosts.where(organization_id: [organization.id, nil])
        hosts_size = hosts.size
        Severity: Minor
        Found in app/services/katello/registration_manager.rb - About 1 hr 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

        Severity
        Category
        Status
        Source
        Language