Sign upLogin

fog/fog-google

View on GitHub
Star
lib/fog/compute/google/mock.rb

Summary

Maintainability
F
1 wk
Test Coverage

Method data has 806 lines of code (exceeds 25 allowed). Consider refactoring.
Open

        def self.data(api_version)
          @data ||= Hash.new do |hash, key|
            case key
            when "debian-cloud"
              hash[key] =
Severity: Major
Found in lib/fog/compute/google/mock.rb - About 4 days to fix

    File mock.rb has 835 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    module Fog
  module Compute
    class Google
      class Mock
        include Fog::Google::Shared
    Severity: Major
    Found in lib/fog/compute/google/mock.rb - About 2 days to fix

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

                          "us-central1" => {
                      "creationTimestamp" => "2014-01-21T10:30:54.895-08:00",
                      "description" => "us-central1",
                      "id" => "18201118976141502843",
                      "kind" => "compute#region",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 1 other location - About 2 hrs to fix
      lib/fog/compute/google/mock.rb on lines 364..383

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

      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

                          "asia-east1" => {
                      "creationTimestamp" => "2014-01-21T10:30:54.895-08:00",
                      "description" => "asia-east1",
                      "id" => "18201118976141502843",
                      "kind" => "compute#region",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 1 other location - About 2 hrs to fix
      lib/fog/compute/google/mock.rb on lines 323..342

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

      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

                          "us-central1-b" => {
                      "kind" => "compute#zone",
                      "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{key}/zones/us-central1-b",
                      "id" => "8701502109626061015",
                      "creationTimestamp" => "2013-09-26T02:56:13.124-07:00",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 1 hr to fix
      lib/fog/compute/google/mock.rb on lines 236..258
      lib/fog/compute/google/mock.rb on lines 297..319

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

      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

                          "europe-west1-a" => {
                      "kind" => "compute#zone",
                      "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{key}/zones/europe-west1-a",
                      "id" => "10419676573632995924",
                      "creationTimestamp" => "2013-09-26T02:56:13.115-07:00",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 1 hr to fix
      lib/fog/compute/google/mock.rb on lines 277..295
      lib/fog/compute/google/mock.rb on lines 297..319

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

      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

                          "us-central2-a" => {
                      "kind" => "compute#zone",
                      "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{key}/zones/us-central2-a",
                      "id" => "13611654493253680292",
                      "creationTimestamp" => "2013-09-26T02:56:13.125-07:00",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 1 hr to fix
      lib/fog/compute/google/mock.rb on lines 236..258
      lib/fog/compute/google/mock.rb on lines 277..295

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

      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

                                              "n1-standard-8-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908560709887590691",
                                          "creationTimestamp" => "2012-06-07T13:51:19.936-07:00",
                                          "name" => "n1-standard-8-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 50 mins to fix
      lib/fog/compute/google/mock.rb on lines 497..517
      lib/fog/compute/google/mock.rb on lines 599..619

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

      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

                                              "n1-highmem-8-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043554021673472746",
                                          "creationTimestamp" => "2012-11-16T11:45:08.195-08:00",
                                          "name" => "n1-highmem-8-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 50 mins to fix
      lib/fog/compute/google/mock.rb on lines 497..517
      lib/fog/compute/google/mock.rb on lines 734..754

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

      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

                                              "n1-highcpu-8-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043557458004959701",
                                          "creationTimestamp" => "2012-11-16T11:51:04.549-08:00",
                                          "name" => "n1-highcpu-8-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 50 mins to fix
      lib/fog/compute/google/mock.rb on lines 599..619
      lib/fog/compute/google/mock.rb on lines 734..754

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

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

                                              "n1-standard-1-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908559201265214706",
                                          "creationTimestamp" => "2012-06-07T13:48:34.258-07:00",
                                          "name" => "n1-standard-1-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 431..448
      lib/fog/compute/google/mock.rb on lines 464..481
      lib/fog/compute/google/mock.rb on lines 533..550
      lib/fog/compute/google/mock.rb on lines 566..583
      lib/fog/compute/google/mock.rb on lines 668..685
      lib/fog/compute/google/mock.rb on lines 701..718

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

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

                                              "n1-highcpu-2-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043555176034896271",
                                          "creationTimestamp" => "2012-11-16T11:47:07.825-08:00",
                                          "name" => "n1-highcpu-2-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 464..481
      lib/fog/compute/google/mock.rb on lines 533..550
      lib/fog/compute/google/mock.rb on lines 566..583
      lib/fog/compute/google/mock.rb on lines 635..652
      lib/fog/compute/google/mock.rb on lines 668..685
      lib/fog/compute/google/mock.rb on lines 701..718

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

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

                                              "n1-highmem-2-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043551625558644085",
                                          "creationTimestamp" => "2012-11-16T11:40:59.630-08:00",
                                          "name" => "n1-highmem-2-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 431..448
      lib/fog/compute/google/mock.rb on lines 464..481
      lib/fog/compute/google/mock.rb on lines 566..583
      lib/fog/compute/google/mock.rb on lines 635..652
      lib/fog/compute/google/mock.rb on lines 668..685
      lib/fog/compute/google/mock.rb on lines 701..718

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

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

                                              "n1-highmem-4-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043552953632709737",
                                          "creationTimestamp" => "2012-11-16T11:43:17.400-08:00",
                                          "name" => "n1-highmem-4-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 431..448
      lib/fog/compute/google/mock.rb on lines 464..481
      lib/fog/compute/google/mock.rb on lines 533..550
      lib/fog/compute/google/mock.rb on lines 635..652
      lib/fog/compute/google/mock.rb on lines 668..685
      lib/fog/compute/google/mock.rb on lines 701..718

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

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

                                              "n1-standard-4-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908559991903153608",
                                          "creationTimestamp" => "2012-06-07T13:50:05.677-07:00",
                                          "name" => "n1-standard-4-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 431..448
      lib/fog/compute/google/mock.rb on lines 464..481
      lib/fog/compute/google/mock.rb on lines 533..550
      lib/fog/compute/google/mock.rb on lines 566..583
      lib/fog/compute/google/mock.rb on lines 635..652
      lib/fog/compute/google/mock.rb on lines 668..685

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

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

                                              "n1-highcpu-4-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043556330284250611",
                                          "creationTimestamp" => "2012-11-16T11:49:07.563-08:00",
                                          "name" => "n1-highcpu-4-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 431..448
      lib/fog/compute/google/mock.rb on lines 533..550
      lib/fog/compute/google/mock.rb on lines 566..583
      lib/fog/compute/google/mock.rb on lines 635..652
      lib/fog/compute/google/mock.rb on lines 668..685
      lib/fog/compute/google/mock.rb on lines 701..718

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

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

                                              "n1-standard-2-d" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908559582417967837",
                                          "creationTimestamp" => "2012-06-07T13:49:19.448-07:00",
                                          "name" => "n1-standard-2-d",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 6 other locations - About 45 mins to fix
      lib/fog/compute/google/mock.rb on lines 431..448
      lib/fog/compute/google/mock.rb on lines 464..481
      lib/fog/compute/google/mock.rb on lines 533..550
      lib/fog/compute/google/mock.rb on lines 566..583
      lib/fog/compute/google/mock.rb on lines 635..652
      lib/fog/compute/google/mock.rb on lines 701..718

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

      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

                          "centos-7-v20161212" => {
                      "archiveSizeBytes" => "4491098988",
                      "creationTimestamp" => "2016-12-14T10 =>29 =>44.741-08 =>00",
                      "description" => "CentOS, CentOS, 7, x86_64 built on 2016-12-12",
                      "diskSizeGb" => "10",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 40 mins to fix
      lib/fog/compute/google/mock.rb on lines 21..39
      lib/fog/compute/google/mock.rb on lines 47..65

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

      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

                          "centos-6-v20161212" => {
                      "archiveSizeBytes" => "3942360630",
                      "creationTimestamp" => "2016-12-14T10 =>30 =>52.053-08 =>00",
                      "description" => "CentOS, CentOS, 6, x86_64 built on 2016-12-12",
                      "diskSizeGb" => "10",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 40 mins to fix
      lib/fog/compute/google/mock.rb on lines 21..39
      lib/fog/compute/google/mock.rb on lines 67..85

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

      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

                          "debian-8-jessie-v20161215" => {
                      "archiveSizeBytes" => "3436783050",
                      "creationTimestamp" => "2016-12-15T12 =>53 =>12.508-08 =>00",
                      "description" => "Debian, Debian GNU/Linux, 8 (jessie), amd64 built on 2016-12-15",
                      "diskSizeGb" => "10",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 40 mins to fix
      lib/fog/compute/google/mock.rb on lines 47..65
      lib/fog/compute/google/mock.rb on lines 67..85

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

      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

                          "fog-3" => {
                      "kind" => "compute#subnetwork",
                      "id" => "6680781458098159923",
                      "creationTimestamp" => "2016-03-19T19:13:51.613-07:00",
                      "gatewayAddress" => "192.168.20.1",
      Severity: Minor
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 40 mins to fix
      lib/fog/compute/google/mock.rb on lines 786..795
      lib/fog/compute/google/mock.rb on lines 797..806

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

      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

                          "fog-2" => {
                      "kind" => "compute#subnetwork",
                      "id" => "6680781458098159921",
                      "creationTimestamp" => "2016-03-19T19:13:51.613-07:00",
                      "gatewayAddress" => "10.1.16.1",
      Severity: Minor
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 40 mins to fix
      lib/fog/compute/google/mock.rb on lines 786..795
      lib/fog/compute/google/mock.rb on lines 808..817

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

      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

                          "fog-1" => {
                      "kind" => "compute#subnetwork",
                      "id" => "6680781458098159920",
                      "creationTimestamp" => "2016-03-19T19:13:51.613-07:00",
                      "gatewayAddress" => "10.1.0.1",
      Severity: Minor
      Found in lib/fog/compute/google/mock.rb and 2 other locations - About 40 mins to fix
      lib/fog/compute/google/mock.rb on lines 797..806
      lib/fog/compute/google/mock.rb on lines 808..817

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

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

                                              "n1-highmem-8" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043553584275586275",
                                          "creationTimestamp" => "2012-11-16T11:44:25.985-08:00",
                                          "name" => "n1-highmem-8",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-standard-2" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908559320241551184",
                                          "creationTimestamp" => "2012-06-07T13:48:56.867-07:00",
                                          "name" => "n1-standard-2",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-highcpu-2" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043554592196512955",
                                          "creationTimestamp" => "2012-11-16T11:46:10.572-08:00",
                                          "name" => "n1-highcpu-2",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-standard-4" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908559692070444049",
                                          "creationTimestamp" => "2012-06-07T13:49:40.050-07:00",
                                          "name" => "n1-standard-4",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-highmem-2" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043551079318055993",
                                          "creationTimestamp" => "2012-11-16T11:40:06.129-08:00",
                                          "name" => "n1-highmem-2",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "f1-micro" => {
                                          "kind" => "compute#machineType",
                                          "id" => "4618642685664990776",
                                          "creationTimestamp" => "2013-04-25T13:32:49.088-07:00",
                                          "name" => "f1-micro",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-highcpu-8" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043556949665240937",
                                          "creationTimestamp" => "2012-11-16T11:50:15.128-08:00",
                                          "name" => "n1-highcpu-8",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-highmem-4" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043552263604939569",
                                          "creationTimestamp" => "2012-11-16T11:42:08.983-08:00",
                                          "name" => "n1-highmem-4",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-standard-1" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12907738072351752276",
                                          "creationTimestamp" => "2012-06-07T13:48:14.670-07:00",
                                          "name" => "n1-standard-1",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-standard-8" => {
                                          "kind" => "compute#machineType",
                                          "id" => "12908560197989714867",
                                          "creationTimestamp" => "2012-06-07T13:50:42.334-07:00",
                                          "name" => "n1-standard-8",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699

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

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

                                              "g1-small" => {
                                          "kind" => "compute#machineType",
                                          "id" => "7224129552184485774",
                                          "creationTimestamp" => "2013-04-25T13:32:45.550-07:00",
                                          "name" => "g1-small",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 450..462
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

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

                                              "n1-highcpu-4" => {
                                          "kind" => "compute#machineType",
                                          "id" => "13043555705736970382",
                                          "creationTimestamp" => "2012-11-16T11:48:06.087-08:00",
                                          "name" => "n1-highcpu-4",
      Severity: Major
      Found in lib/fog/compute/google/mock.rb and 11 other locations - About 35 mins to fix
      lib/fog/compute/google/mock.rb on lines 389..401
      lib/fog/compute/google/mock.rb on lines 403..415
      lib/fog/compute/google/mock.rb on lines 417..429
      lib/fog/compute/google/mock.rb on lines 483..495
      lib/fog/compute/google/mock.rb on lines 519..531
      lib/fog/compute/google/mock.rb on lines 552..564
      lib/fog/compute/google/mock.rb on lines 585..597
      lib/fog/compute/google/mock.rb on lines 621..633
      lib/fog/compute/google/mock.rb on lines 654..666
      lib/fog/compute/google/mock.rb on lines 687..699
      lib/fog/compute/google/mock.rb on lines 720..732

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

      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