vcloud-core 0.0.1

data/spec/vcloud/core/metadata_helper_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe MetadataHelper do
+      context "get_metadata" do
+
+        it "should process valid metadata types" do
+          metadata_entries = [
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => 'role_name',
+                  :TypedValue => {
+                      :xsi_type => 'MetadataStringValue',
+                      :Value => 'james-bond'
+                  }},
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => "server_number",
+                  :TypedValue => {:xsi_type => "MetadataNumberValue", :Value => "-10"}
+              },
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => "created_at",
+                  :TypedValue => {:xsi_type => "MetadataDateTimeValue", :Value => "2013-12-16T14:30:05.000Z"}
+              },
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => "daily_shutdown",
+                  :TypedValue => {:xsi_type => "MetadataBooleanValue", :Value => "false"}
+              }
+          ]
+          metadata = MetadataHelper.extract_metadata(metadata_entries)
+          metadata.count.should == 4
+          metadata[:role_name].should == 'james-bond'
+          metadata[:server_number].should == -10
+          metadata[:created_at].should == DateTime.parse("2013-12-16T14:30:05.000Z")
+          metadata[:daily_shutdown].should == false
+        end
+
+        it "should skip metadata entry if entry type is not application/vnd.vmware.vcloud.metadata.value+xml" do
+          metadata_entries = [
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => 'role_name',
+                  :TypedValue => {
+                      :xsi_type => 'MetadataStringValue',
+                      :Value => 'james-bond'
+                  }},
+              {
+                  :Key => "untyped_key",
+                  :TypedValue => {:xsi_type => "MetadataNumberValue", :Value => "-10"}
+              },
+
+          ]
+          metadata = MetadataHelper.extract_metadata(metadata_entries)
+          metadata.count.should == 1
+          metadata.keys.should_not include :untyped_key
+        end
+
+        it "should include unrecognized metadata types" do
+          metadata_entries = [
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => 'role_name',
+                  :TypedValue => {
+                      :xsi_type => 'MetadataStringValue',
+                      :Value => 'james-bond'
+                  }},
+              {
+                  :type => Fog::ContentTypes::METADATA,
+                  :Key => "unrecognized_type_key",
+                  :TypedValue => {:xsi_type => "MetadataWholeNumberValue", :Value => "-10"}
+              },
+
+          ]
+          metadata = MetadataHelper.extract_metadata(metadata_entries)
+          metadata.count.should == 2
+          metadata.keys.should include :unrecognized_type_key
+        end
+
+
+      end
+
+
+    end
+
+  end
+end

data/spec/vcloud/core/org_vdc_network_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe OrgVdcNetwork do
+
+      before (:each) do
+        @vdc_id    = '12345678-1234-1234-1234-000000111111'
+        @edgegw_id = '12345678-1234-1234-1234-000000222222'
+        @net_id    = '12345678-1234-1234-1234-000000333333'
+        @vdc_name  = 'test-vdc-1'
+        @net_name  = 'test-net-1'
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        Vdc.any_instance.stub(:id).and_return(@vdc_id)
+        @mock_vdc = double(:vdc, :id => @vdc_id)
+        Vdc.stub(:get_by_name).and_return(@mock_vdc)
+      end
+
+      context "Class public interface" do
+        it { OrgVdcNetwork.should respond_to(:provision) }
+      end
+
+      context "Object public interface" do
+        subject { OrgVdcNetwork.new(@net_id) }
+        it { should respond_to(:id) }
+        it { should respond_to(:name) }
+        it { should respond_to(:href) }
+        it { should respond_to(:delete) }
+      end
+
+      context "#initialize" do
+
+        it "should be constructable from just an id reference" do
+          obj = OrgVdcNetwork.new(@net_id)
+          expect(obj.class).to be(Vcloud::Core::OrgVdcNetwork)
+        end
+
+        it "should store the id specified" do
+          obj = OrgVdcNetwork.new(@net_id)
+          expect(obj.id) == @net_id
+        end
+
+        it "should raise error if id is not in correct format" do
+          bogus_id = '123123-bogus-id-123445'
+          expect{ OrgVdcNetwork.new(bogus_id) }.
+            to raise_error("orgVdcNetwork id : #{bogus_id} is not in correct format" )
+        end
+
+      end
+
+      context "#delete" do
+        it "should call down to Fog::ServiceInterface.delete_network with the correct id" do
+          @mock_fog_interface.should_receive(:delete_network).with(@net_id)
+          OrgVdcNetwork.new(@net_id).delete
+        end
+      end
+
+      context "#provision" do
+
+        before(:each) do
+          @mock_vdc = double(
+            :vdc,
+            :id => @vdc_id,
+            :href => "/#{@vdc_id}",
+            :name => @vdc_name
+          )
+          Vdc.stub(:get_by_name).and_return(@mock_vdc)
+        end
+
+        context "should fail gracefully on bad input" do
+
+          before(:each) do
+            @config = {
+              :name => @net_name,
+              :vdc_name => @vdc_name,
+              :fence_mode => 'isolated'
+            }
+          end
+
+          it "should fail if :name is not set" do
+            @config.delete(:name)
+            expect { Vcloud::Core::OrgVdcNetwork.provision(@config) }.
+              to raise_exception(RuntimeError)
+          end
+
+          it "should fail if :vdc_name is not set" do
+            @config.delete(:vdc_name)
+            expect { Vcloud::Core::OrgVdcNetwork.provision(@config) }.
+              to raise_exception(RuntimeError)
+          end
+
+          it "should fail if :fence_mode is not set" do
+            @config.delete(:fence_mode)
+            expect { Vcloud::Core::OrgVdcNetwork.provision(@config) }.
+              to raise_exception(RuntimeError)
+          end
+
+          it "should fail if :fence_mode is not 'isolated' or 'natRouted'" do
+            @config[:fence_mode] = 'testfail'
+            expect { Vcloud::Core::OrgVdcNetwork.provision(@config) }.
+              to raise_exception(RuntimeError)
+          end
+
+        end
+
+        context "isolated orgVdcNetwork" do
+
+          before(:each) do
+            q_results = [
+              { :name => @net_name, :href => "/#{@net_id}" }
+            ]
+            @mock_net_query = double(:query, :get_all_results => q_results)
+            @config = {
+              :name => @net_name,
+              :vdc_name => @vdc_name,
+              :fence_mode => 'isolated'
+            }
+          end
+
+          it "should create an OrgVdcNetwork with minimal config" do
+            expected_vcloud_attrs = {
+              :IsShared => false,
+              :Configuration => {
+                :FenceMode => 'isolated',
+                :IpScopes => {
+                  :IpScope => {
+                    :IsInherited => false,
+                    :IsEnabled => true
+                  }
+                }
+              },
+            }
+            Vcloud::Core.logger.should_receive(:info)
+            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+                with(@vdc_id, @config[:name], expected_vcloud_attrs).
+                and_return({ :href => "/#{@net_id}" })
+            obj = Vcloud::Core::OrgVdcNetwork.provision(@config)
+            expect(obj.id) == @net_id
+          end
+
+          it "should handle specification of one ip_ranges" do
+            @config[:ip_ranges] = [
+              { :start_address => '10.53.53.100', :end_address => '10.53.53.110' }
+            ]
+            expected_vcloud_attrs = {
+              :IsShared => false,
+              :Configuration => {
+                :FenceMode => 'isolated',
+                :IpScopes => {
+                  :IpScope => {
+                    :IsInherited => false,
+                    :IsEnabled => true,
+                    :IpRanges => [{
+                      :IpRange => {
+                        :StartAddress => '10.53.53.100',
+                        :EndAddress => '10.53.53.110'
+                      },
+                    }],
+                  }
+                }
+              }
+            }
+            Vcloud::Core.logger.should_receive(:info)
+            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+                with(@vdc_id, @config[:name], expected_vcloud_attrs).
+                and_return({ :href => "/#{@net_id}" })
+            obj = Vcloud::Core::OrgVdcNetwork.provision(@config)
+          end
+
+          it "should handle specification of two ip_ranges" do
+            @config[:ip_ranges] = [
+              { :start_address => '10.53.53.100', :end_address => '10.53.53.110' },
+              { :start_address => '10.53.53.120', :end_address => '10.53.53.130' },
+            ]
+            expected_vcloud_attrs = {
+              :IsShared => false,
+              :Configuration => {
+                :FenceMode => 'isolated',
+                :IpScopes => {
+                  :IpScope => {
+                    :IsInherited => false,
+                    :IsEnabled => true,
+                    :IpRanges => [
+                      { :IpRange =>
+                        {
+                          :StartAddress => '10.53.53.100',
+                          :EndAddress => '10.53.53.110'
+                        }
+                      },
+                      { :IpRange =>
+                        {
+                          :StartAddress => '10.53.53.120',
+                          :EndAddress => '10.53.53.130'
+                        }
+                      },
+                    ]
+                  }
+                }
+              },
+            }
+            Vcloud::Core.logger.should_receive(:info)
+            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+                with(@vdc_id, @config[:name], expected_vcloud_attrs).
+                and_return({ :href => "/#{@net_id}" })
+            obj = Vcloud::Core::OrgVdcNetwork.provision(@config)
+          end
+
+        end
+
+        context "natRouted orgVdcNetwork" do
+
+          before(:each) do
+            @config = {
+              :name => @net_name,
+              :vdc_name => @vdc_name,
+              :fence_mode => 'natRouted'
+            }
+          end
+
+          it "should fail if an edge_gateway is not supplied" do
+            expect{ Vcloud::Core::OrgVdcNetwork.provision(@config) }.
+              to raise_exception(RuntimeError)
+          end
+
+          it "should handle lack of ip_ranges on natRouted networks" do
+            @config[:edge_gateway] = 'test gateway'
+            mock_edgegw = Vcloud::Core::EdgeGateway.new(@edgegw_id)
+            Vcloud::Core::EdgeGateway.stub(:get_by_name).and_return(mock_edgegw)
+
+            expected_vcloud_attrs = {
+              :IsShared => false,
+              :Configuration => {
+                :FenceMode => 'natRouted',
+                :IpScopes => {
+                  :IpScope => {
+                    :IsInherited => false,
+                    :IsEnabled => true
+                  }
+                }
+              },
+              :EdgeGateway => { :href => "/#{@edgegw_id}" },
+            }
+            Vcloud::Core.logger.should_receive(:info)
+            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+                with(@vdc_id, @config[:name], expected_vcloud_attrs).
+                and_return({ :href => "/#{@net_id}" })
+            obj = Vcloud::Core::OrgVdcNetwork.provision(@config)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/spec/vcloud/core/query_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Vcloud::Query do
+  context "attributes" do
+
+    context "our object should have methods" do
+      before(:each) do
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        @query = Vcloud::Query.new()
+      end
+      it { @query.should respond_to(:run) }
+    end
+
+    context "#run with no type set" do
+      
+      before(:each) do
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        @query = @query = Vcloud::Query.new()
+      end
+
+      it "should call output_potential_query_types when run not provided with a type" do
+        @query.should_receive(:output_potential_query_types)
+        @query.run()
+      end
+
+      it "should output viable types when run not provided with a type" do
+        @mock_fog_interface.stub(:get_execute_query).and_return( 
+          { :Link => [
+            {:rel=>"down",
+             :href=>"query?type=alice&format=references"},
+            {:rel=>"down",
+             :href=>"query?type=alice&format=records"},
+            {:rel=>"down",
+             :href=>"query?type=bob&format=records"},
+        ]})
+
+        @query.should_receive(:puts).with("alice records,references")
+        @query.should_receive(:puts).with("bob   records")
+
+        @query.run
+      end
+
+    end
+
+    context "gracefully handle zero results" do
+      before(:each) do
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        @query = Vcloud::Query.new('bob')
+        @mock_fog_interface.stub(:get_execute_query).and_return({})
+      end
+
+      it "should not output when given tsv output_format" do
+        @query = Vcloud::Query.new('bob', :output_format => 'tsv')
+        @query.should_not_receive(:puts)
+        @query.run()
+      end
+
+      it "should not output when given csv output_format" do
+        @query = Vcloud::Query.new('bob', :output_format => 'csv')
+        @query.should_not_receive(:puts)
+        @query.run()
+      end
+
+    end
+
+    context "get results with a single response page" do
+
+      before(:each) do
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        @query = Vcloud::Query.new('bob')
+        @mock_fog_interface.stub(:get_execute_query).and_return( { 
+          :WibbleRecord=>
+            [{:field1=>"Stuff 1",
+              :field2=>"Stuff 2",
+              :field3=>"Stuff 3",
+            },
+             {:field1=>"More Stuff 1",
+              :field2=>"More Stuff 2",
+              :field3=>"More Stuff 3",
+            },
+            ]
+        } )
+      end
+
+      it "should output a query in tsv when run with a type" do
+        @query = Vcloud::Query.new('bob', :output_format => 'tsv')
+        @query.should_receive(:puts).with("field1\tfield2\tfield3")
+        @query.should_receive(:puts).with("Stuff 1\tStuff 2\tStuff 3")
+        @query.should_receive(:puts).with("More Stuff 1\tMore Stuff 2\tMore Stuff 3")
+        @query.run()
+      end
+
+      it "should output a query in csv when run with a type" do
+        @query = Vcloud::Query.new('bob', :output_format => 'csv')
+        @query.should_receive(:puts).with("field1,field2,field3\n")
+        @query.should_receive(:puts).with("Stuff 1,Stuff 2,Stuff 3\nMore Stuff 1,More Stuff 2,More Stuff 3\n")
+        @query.run()
+      end
+
+#      it "should output a query in yaml when run with a type"
+
+    end
+
+  end
+
+end
+