vcloud-walker 3.2.2 → 3.2.3

data/.travis.yml

@@ -0,0 +1,8 @@
+---
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+notifications:
+  email: false

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 3.2.3 (2014-07-14)
+
+Bugfixes:
+
+  - Prevent an "undefined method for nil:Nilclass" exception when
+    encountering a vApp that has no networks attached.
+
+API changes:
+
+  - Vcloud::Walker::walk now returns an exception if provided an invalid
+    resource type instead of returning a `nil` object and printing the valid
+    options to STDOUT.
+
+Bugfixes:
+
+  - Rename Rake integration test from 'integration_test' to 'integration' for consistency with other vCloud Tools
+
 ## 3.2.2 (2014-05-01)
 
   - Use pessimistic version dependency for vcloud-core

data/CONTRIBUTING.md

@@ -0,0 +1,66 @@
+# Contributing to vCloud Walker
+
+We really welcome contributions.
+
+## A quick guide on how to contribute
+
+1. Clone the repo:
+
+        git clone git@github.com:gds-operations/vcloud-walker.git
+
+2. Run `bundle` to get the required dependecies
+
+3. Run the tests. Pull requests that add features must include unit tests,
+   so it is good to ensure you've got them passing to begin with.
+
+        bundle exec rake
+
+   If you have access to a live environment for testing, it would be great
+   if you could run the integration tests too - for more details on the
+   set-up for that, please see the [integration tests README]
+   (https://github.com/gds-operations/vcloud-walker/blob/master/spec/integration/README.md)
+
+4. Add your functionality or bug fix and a test for your change. Only refactoring and
+   documentation changes do not require tests. If the functionality is at all complicated
+   then it is likely that more than one test will be required. If you would like help
+   with writing tests please do ask us.
+
+5. Make sure all the tests pass, including the integration tests if possible.
+
+6. Update the [CHANGELOG](https://github.com/gds-operations/vcloud-walker/blob/master/CHANGELOG.md)
+   with a short description of what the change is. This may be a feature, a bugfix, or an
+   API change. If your change is documenation or refactoring, you do not need to add a line
+   to the CHANGELOG.
+
+7. Fork the repo, push to your fork, and submit a pull request.
+
+## How soon will we respond?
+
+We will comment on your pull request within two working days. However, we might not be able to review it immediately.
+
+We may come back to you with comments and suggestions, and if we would like you to make changes, we will close the pull request as well as adding details of the changes we'd like you to make.
+
+If you feel your pull request has been outstanding too long, please feel free to bump it by making a comment on it.
+
+## Guidelines for making a pull request
+
+    The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD",
+    "SHOULD NOT", "RECOMMENDED",  "MAY", and "OPTIONAL" in this document are to be
+    interpreted as described in RFC 2119.
+
+## In order for a pull request to be accepted, it MUST
+
+- Include at least one test (unless it is documentation or refactoring). If you have any questions about how to write tests, please ask us, we will be happy to help
+- Follow our [Git style guide](https://github.com/alphagov/styleguides/blob/master/git.md)
+- Include a clear summary in the pull request comments as to what the change is and why
+  you are making it
+- Be readable - we might ask you to change unclear variable names or obscure syntactic sugar
+- Have [good commit messages](http://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message)
+  that explain the change being made in that commit. Don't be afraid to write a lot in the
+  detail.
+
+## In order for a pull request to be accepted, it SHOULD
+
+- Include a line in the CHANGELOG unless it is a refactoring or documentation change
+- If it is code, follow our [Ruby style guide](https://github.com/alphagov/styleguides/blob/master/ruby.md)
+- If it is documentation, follow the [GDS content style guide](https://www.gov.uk/design-principles/style-guide/style-points)

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 if ENV['VCLOUD_WALKER_DEV_FOG_MASTER']
   gem 'fog', :git => 'git@github.com:fog/fog.git', :branch => 'master'
-  gem 'vcloud-core', :git => 'git@github.com:alphagov/vcloud-core.git', :branch => 'master'
+  gem 'vcloud-core', :git => 'git@github.com:gds-operations/vcloud-core.git', :branch => 'master'
 elsif ENV['VCLOUD_WALKER_DEV_FOG_LOCAL']
   gem 'fog', :path => '../fog'
   gem 'vcloud-core', :path => '../vcloud-core'

data/README.md

@@ -110,3 +110,13 @@ If you want to be sure you are pinning to 5.1, or use 5.5, you can set the API v
 `export EXCON_DEBUG=true` - this will print out the API requests and responses.
 
 `export DEBUG=true` - this will show you the stack trace when there is an exception instead of just the message.
+
+## Testing
+
+Run the default suite of tests (e.g. lint, unit, features):
+
+    bundle exec rake
+
+Run the integration tests (slower and requires a real environment):
+
+    bundle exec rake integration

data/Rakefile

@@ -4,18 +4,23 @@ require 'rspec/core/rake_task'
 require 'vcloud/walker/version'
 
 RSpec::Core::RakeTask.new(:spec) do |task|
-ENV['COVERAGE'] = 'true'
-task.pattern = FileList['spec/**/*_spec.rb'] - FileList['spec/integration/*_spec.rb']
+  ENV['COVERAGE'] = 'true'
+  task.pattern = FileList['spec/**/*_spec.rb'] - FileList['spec/integration/*_spec.rb']
 end
 
-RSpec::Core::RakeTask.new(:integration_test) do |task|
-task.pattern = FileList['spec/integration/*_spec.rb']
+RSpec::Core::RakeTask.new(:integration) do |task|
+  task.pattern = FileList['spec/integration/*_spec.rb']
 end
 
-task :default => :spec
+task :default => [ :rubocop, :spec ]
 
 require "gem_publisher"
-task :publish_gem do |t|
+task :publish_gem do
   gem = GemPublisher.publish_if_updated("vcloud-walker.gemspec", :rubygems)
   puts "Published #{gem}" if gem
 end
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['--lint']
+end

data/bin/vcloud-walk

@@ -1,40 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
-require 'methadone'
-
-require 'json'
 require 'vcloud/walker'
 
-class App
-  include Methadone::Main
-  include Methadone::CLILogging
-  include Vcloud
-
-  main do |resource_to_walk|
-    walker_output = Vcloud::Walker.walk(resource_to_walk)
-    options[:yaml] ? print(walker_output.to_yaml)  :  print(JSON.pretty_generate walker_output)
-  end
-
-  on("--verbose", "Verbose output")
-  on("--debug",   "Debugging output")
-  on("--yaml",   "Yaml output")
-
-  arg :resource_to_walk
-
-  description '
-  Vcloud-walker is a command line tool, to describe different VMware vCloud Director 5.1 resources. It uses Fog under the hood.
-
-  Resources that can be walked using vcloud-walker are:
-    catalogs
-    vdcs
-    networks
-    edgegateways
-    organization
-
-  See https://github.com/alphagov/vcloud-walker for more info'
-
-  version Vcloud::Walker::VERSION
-
-  go!
-end
+Vcloud::Walker::Cli.new(ARGV).run

data/jenkins.sh

@@ -7,6 +7,6 @@ git clean -fdx
 bundle install --path "${HOME}/bundles/${JOB_NAME}"
 bundle exec rake
 
-RUBYOPT="-r ./tools/fog_credentials" bundle exec rake integration_test
+RUBYOPT="-r ./tools/fog_credentials" bundle exec rake integration
 
 bundle exec rake publish_gem

data/jenkins_integration_tests.sh

@@ -2,4 +2,4 @@
 set -e
 bundle install --path "${HOME}/bundles/${JOB_NAME}"
 
-RUBYOPT="-r ./tools/fog_credentials" bundle exec rake integration_test
+RUBYOPT="-r ./tools/fog_credentials" bundle exec rake integration

data/lib/vcloud/walker/cli.rb

@@ -0,0 +1,82 @@
+require 'optparse'
+require 'json'
+
+module Vcloud
+  module Walker
+    class Cli
+      def initialize(argv_array)
+        @usage_text = nil
+        @resource_type = nil
+        @options = {
+          :yaml => false,
+        }
+
+        parse(argv_array)
+      end
+
+      def run
+        begin
+          out = Vcloud::Walker.walk(@resource_type)
+          if @options[:yaml]
+            print(out.to_yaml)
+          else
+            print(JSON.pretty_generate(out))
+          end
+        rescue => e
+          $stderr.puts(e)
+          exit 1
+        end
+      end
+
+      private
+
+      def parse(args)
+        opt_parser = OptionParser.new do |opts|
+          opts.banner = <<-EOS
+Usage: #{$0} [options] resource_type
+Vcloud-walker is a command line tool, to describe different VMware vCloud Director 5.1 resources. It uses Fog under the hood.
+
+Resources that can be walked using vcloud-walker are:
+  catalogs
+  vdcs
+  networks
+  edgegateways
+  organization
+
+See https://github.com/gds-operations/vcloud-walker for more info
+          EOS
+
+          opts.on("--yaml",   "Yaml output") do
+            @options[:yaml] = true
+          end
+
+          opts.on("-h", "--help", "Print usage and exit") do
+            $stderr.puts opts
+            exit
+          end
+
+          opts.on("--version", "Display version and exit") do
+            puts Vcloud::Walker::VERSION
+            exit
+          end
+        end
+
+        @usage_text = opt_parser.to_s
+        begin
+          opt_parser.parse!(args)
+        rescue OptionParser::InvalidOption => e
+          exit_error_usage(e)
+        end
+
+        exit_error_usage("must supply resource_type") unless args.size == 1
+        @resource_type = args.first
+      end
+
+      def exit_error_usage(error)
+        $stderr.puts "#{$0}: #{error}"
+        $stderr.puts @usage_text
+        exit 2
+      end
+    end
+  end
+end

data/lib/vcloud/walker/fog_interface.rb

@@ -36,7 +36,6 @@ module Vcloud
         VcloudSession.instance.get_vapp(vapp_id).body
       end
 
-      private
       def self.get_org
         vcloud = VcloudSession.instance
         vcloud.organizations.get_by_name(vcloud.org_name)

data/lib/vcloud/walker/resource/vapp.rb

@@ -10,14 +10,18 @@ module Vcloud
           @description = fog_vapp[:Description]
           @deployed = fog_vapp[:deployed]
           @id = extract_id(fog_vapp[:href])
-          @network_config  = extract_network_config(fog_vapp[:NetworkConfigSection][:NetworkConfig])
-          @network_section = fog_vapp[:'ovf:NetworkSection'][:'ovf:Network']
+          @network_config  = extract_network_config(fog_vapp)
+          @network_section = extract_network_section(fog_vapp)
           @vms             = Resource::Vms.new(fog_vapp[:Children][:Vm])
           @metadata = Vcloud::Core::Vapp.get_metadata(id)
         end
 
         private
-        def extract_network_config network_configs
+        def extract_network_config fog_vapp
+          return [] unless fog_vapp.key?(:NetworkConfigSection)
+          return [] unless fog_vapp[:NetworkConfigSection].key?(:NetworkConfig)
+
+          network_configs = fog_vapp[:NetworkConfigSection][:NetworkConfig]
           (network_configs.is_a?(Hash) ? [network_configs] : network_configs).collect do |network_config|
             {
               network_name:   network_config[:networkName],
@@ -31,6 +35,11 @@ module Vcloud
           end
         end
 
+        def extract_network_section fog_vapp
+          return {} unless fog_vapp.key?(:'ovf:NetworkSection')
+
+          fog_vapp[:'ovf:NetworkSection'].fetch(:'ovf:Network', {})
+        end
       end
 
       class VApps < Collection

data/lib/vcloud/walker/version.rb

@@ -1,5 +1,5 @@
 module Vcloud
   module Walker
-    VERSION = '3.2.2'
+    VERSION = '3.2.3'
   end
 end

data/lib/vcloud/walker.rb

@@ -1,6 +1,7 @@
 require 'fog'
 
 require 'vcloud/core'
+require 'vcloud/walker/cli'
 require 'vcloud/walker/vcloud_session'
 require 'vcloud/walker/fog_interface'
 require 'vcloud/walker/resource'
@@ -8,15 +9,14 @@ require 'vcloud/walker/version'
 
 module Vcloud
   module Walker
+    VALID_RESOURCES = %w{catalogs vdcs networks edgegateways organization}
 
     def self.walk(resource_to_walk)
-      valid_options = ['catalogs', 'vdcs', 'networks',
-                        'edgegateways', 'organization']
-      if valid_options.include? resource_to_walk
-        Vcloud::Walker::Resource::Organization.send(resource_to_walk)
-      else
-         puts "Possible options are '#{valid_options.join("','")}'."
+      unless VALID_RESOURCES.include?(resource_to_walk)
+         raise "Invalid resource '#{resource_to_walk}'. Possible options are '#{VALID_RESOURCES.join("','")}'."
       end
+
+      Vcloud::Walker::Resource::Organization.send(resource_to_walk)
     end
 
   end

data/spec/fog_interface_spec.rb

@@ -8,51 +8,46 @@ describe Vcloud::Walker::FogInterface do
     let(:session) { double(:fog_session, :org_name => 'org-123', :organizations => organizations) }
 
     before(:each) do
-      Vcloud::Walker::VcloudSession.should_receive(:instance).with(any_args()).at_least(:once).and_return(session)
-      organizations.should_receive(:get_by_name).and_return(org)
+      expect(Vcloud::Walker::VcloudSession).to receive(:instance).with(any_args()).at_least(:once).and_return(session)
+      expect(organizations).to receive(:get_by_name).and_return(org)
     end
 
     it "should get catalogs for given org id" do
       mock_catalogs = [double(:catalog1), double(:catalog2)]
-      org.should_receive(:catalogs).and_return(double(:catalogs, :all => mock_catalogs))
-
+      expect(org).to receive(:catalogs).and_return(double(:catalogs, :all => mock_catalogs))
       catalogs = Vcloud::Walker::FogInterface.get_catalogs
-
-      catalogs.count.should == 2
-      catalogs.should == mock_catalogs
-
+      expect(catalogs.count).to eq(2)
+      expect(catalogs).to eq(mock_catalogs)
     end
 
     it "should get networks for given org id" do
       mock_networks = [double(:network1), double(:network2)]
-      org.should_receive(:networks).and_return(double(:networks, :all => mock_networks))
-
+      expect(org).to receive(:networks).and_return(double(:networks, :all => mock_networks))
       networks = Vcloud::Walker::FogInterface.get_networks
-      networks.count.should == 2
-      networks.should == mock_networks
+      expect(networks.count).to eq(2)
+      expect(networks).to eq(mock_networks)
     end
 
     it "should get vdcs for given org id" do
       mock_vdcs = [double(:vdc1), double(:vdc2), double(:vdc3)]
-      org.should_receive(:vdcs).and_return(double(:vdcs, :all => mock_vdcs))
-
+      expect(org).to receive(:vdcs).and_return(double(:vdcs, :all => mock_vdcs))
       vdcs = Vcloud::Walker::FogInterface.get_vdcs
-      vdcs.count.should == 3
-      vdcs.should == mock_vdcs
+      expect(vdcs.count).to eq(3)
+      expect(vdcs).to eq(mock_vdcs)
     end
 
     it "should get edge gateways for given org" do
       mock_vdc1 = double(:vdc, :id => 1)
       get_edge_gateway_result = double('Excon::Response', :body => {:EdgeGatewayRecord => {:href => '/sausage'}})
 
-      org.should_receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1 ]))
-      session.should_receive(:get_org_vdc_gateways).with(1).and_return(get_edge_gateway_result)
-      session.should_receive(:get_edge_gateway).with('sausage').and_return(double(:eg, :body => :eg1))
+      expect(org).to receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1 ]))
+      expect(session).to receive(:get_org_vdc_gateways).with(1).and_return(get_edge_gateway_result)
+      expect(session).to receive(:get_edge_gateway).with('sausage').and_return(double(:eg, :body => :eg1))
 
       edge_gateways = Vcloud::Walker::FogInterface.get_edge_gateways
 
-      edge_gateways.count.should == 1
-      edge_gateways.should == [:eg1]
+      expect(edge_gateways.count).to eq(1)
+      expect(edge_gateways).to eq([:eg1])
     end
 
     it "should get edge gateways for given org with complex set up of 2 vdcs and 3 edge gateways" do
@@ -61,18 +56,18 @@ describe Vcloud::Walker::FogInterface do
       mock_vdc2 = double(:vdc, :id => 2)
       get_edge_gateway_vdc_2_result = double('Excon::Response', :body => {:EdgeGatewayRecord => [{:href => '/beans'}, {:href => '/hashbrown'}]})
 
-      org.should_receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1, mock_vdc2 ]))
+      expect(org).to receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1, mock_vdc2 ]))
 
-      session.should_receive(:get_org_vdc_gateways).with(1).and_return(get_edge_gateway_vdc_1_result)
-      session.should_receive(:get_org_vdc_gateways).with(2).and_return(get_edge_gateway_vdc_2_result)
-      session.should_receive(:get_edge_gateway).with('sausage').and_return(double(:eg, :body => :eg1))
-      session.should_receive(:get_edge_gateway).with('beans').and_return(double(:eg, :body => :eg2))
-      session.should_receive(:get_edge_gateway).with('hashbrown').and_return(double(:eg, :body => :eg3))
+      expect(session).to receive(:get_org_vdc_gateways).with(1).and_return(get_edge_gateway_vdc_1_result)
+      expect(session).to receive(:get_org_vdc_gateways).with(2).and_return(get_edge_gateway_vdc_2_result)
+      expect(session).to receive(:get_edge_gateway).with('sausage').and_return(double(:eg, :body => :eg1))
+      expect(session).to receive(:get_edge_gateway).with('beans').and_return(double(:eg, :body => :eg2))
+      expect(session).to receive(:get_edge_gateway).with('hashbrown').and_return(double(:eg, :body => :eg3))
 
       edge_gateways = Vcloud::Walker::FogInterface.get_edge_gateways
 
-      edge_gateways.count.should == 3
-      edge_gateways.should == [:eg1, :eg2, :eg3]
+      expect(edge_gateways.count).to eq(3)
+      expect(edge_gateways).to eq([:eg1, :eg2, :eg3])
     end
 
     it "get_edge_gateways should be happy if there are no edge gateways" do
@@ -81,13 +76,13 @@ describe Vcloud::Walker::FogInterface do
       # no edge gateways means no entries to find in the results, just some other noise
       vdc_1_search_result = double('Excon::Response', :body => {:Link => {:href => 's'}})
 
-      org.should_receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1 ]))
-      session.should_receive(:get_org_vdc_gateways).with(1).and_return(vdc_1_search_result)
+      expect(org).to receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1 ]))
+      expect(session).to receive(:get_org_vdc_gateways).with(1).and_return(vdc_1_search_result)
 
       edge_gateways = Vcloud::Walker::FogInterface.get_edge_gateways
 
-      edge_gateways.count.should == 0
+      expect(edge_gateways.count).to eq(0)
     end
 
   end
-end
+end

data/spec/integration/vcloud_walker_spec.rb

@@ -31,11 +31,11 @@ describe Vcloud::Walker do
       vdc_summaries = Vcloud::Walker.walk('vdcs').to_json
 
       # assert that there are atleast one item and that includes the essencial sections
-      vdc_summaries.should have_json_path('0/id')
-      vdc_summaries.should have_json_path('0/name')
-      vdc_summaries.should have_json_path('0/vapps')
-      vdc_summaries.should have_json_path('0/quotas')
-      vdc_summaries.should have_json_path('0/compute_capacity')
+      expect(vdc_summaries).to have_json_path('0/id')
+      expect(vdc_summaries).to have_json_path('0/name')
+      expect(vdc_summaries).to have_json_path('0/vapps')
+      expect(vdc_summaries).to have_json_path('0/quotas')
+      expect(vdc_summaries).to have_json_path('0/compute_capacity')
     end
 
     it "should integrate with fog to get networks" do
@@ -43,10 +43,10 @@ describe Vcloud::Walker do
       network_summary = Vcloud::Walker.walk('networks').to_json
 
       # assert that there are atleast one item and that includes the essencial sections
-      network_summary.should have_json_path('0/id')
-      network_summary.should have_json_path('0/name')
-      network_summary.should have_json_path('0/ip_ranges')
-      network_summary.should have_json_path('0/gateway')
+      expect(network_summary).to have_json_path('0/id')
+      expect(network_summary).to have_json_path('0/name')
+      expect(network_summary).to have_json_path('0/ip_ranges')
+      expect(network_summary).to have_json_path('0/gateway')
     end
 
     it "should integrate with fog to get catalogs" do
@@ -55,20 +55,20 @@ describe Vcloud::Walker do
       catalog_summary = catalogs_summary.detect{|c| !c[:items].empty? }.to_json
 
       # assert that there are atleast one item and that includes the essencial sections
-      catalog_summary.should have_json_path('id')
-      catalog_summary.should have_json_path('name')
-      catalog_summary.should have_json_path('items')
-      catalog_summary.should have_json_path('items/0/vapp_template_id')
+      expect(catalog_summary).to have_json_path('id')
+      expect(catalog_summary).to have_json_path('name')
+      expect(catalog_summary).to have_json_path('items')
+      expect(catalog_summary).to have_json_path('items/0/vapp_template_id')
     end
 
     it "should integrate with fog to get edge gateway data" do
 
       result = Vcloud::Walker.walk('edgegateways').to_json
       # assert that there are atleast one item and that includes the essencial sections
-      result.should have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/FirewallService')
-      result.should have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/NatService')
-      result.should have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/LoadBalancerService')
-      result.should have_json_path('0/Configuration/GatewayInterfaces/GatewayInterface')
+      expect(result).to have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/FirewallService')
+      expect(result).to have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/NatService')
+      expect(result).to have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/LoadBalancerService')
+      expect(result).to have_json_path('0/Configuration/GatewayInterfaces/GatewayInterface')
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,14 +1,22 @@
+# SimpleCov must run _first_ according to its README
 if ENV['COVERAGE']
   require 'simplecov'
 
-  SimpleCov.profiles.define 'gem' do
+  # monkey-patch to prevent SimpleCov from reporting coverage percentage
+  class SimpleCov::Formatter::HTMLFormatter
+    def output_message(_message)
+      nil
+    end
+  end
+
+  SimpleCov.adapters.define 'gem' do
     add_filter '/spec/'
-    add_filter '/features/'
     add_filter '/vendor/'
 
     add_group 'Libraries', '/lib/'
   end
 
+  SimpleCov.minimum_coverage(99)
   SimpleCov.start 'gem'
 end
 
@@ -29,17 +37,7 @@ end
 
 RSpec.configure do |config|
   config.include JsonSpec::Helpers
-end
-
-if ENV['COVERAGE']
-  ACCEPTED_COVERAGE = 97
-  SimpleCov.at_exit do
-    SimpleCov.result.format!
-    # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
-    if SimpleCov.result.covered_percent < ACCEPTED_COVERAGE
-      print "ERROR::BAD_CODE_COVERAGE\n"
-      print "Coverage is less than acceptable limit(#{ACCEPTED_COVERAGE}%). Please add more tests to improve the coverage"
-      exit(1)
-    end
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
   end
-end
+end

data/spec/stubs/stubs.rb

@@ -1,5 +1,4 @@
 class StubVdc
-  @edge_gateways
 
   def initialize
     @edge_gateways = []