vcloud-core 1.0.0 → 1.0.1

data/spec/vcloud/core/independent_disk_spec.rb

@@ -73,7 +73,7 @@ describe Vcloud::Core::IndependentDisk do
     end
 
     it "should raise an error if multiple Independent Disks with " +
-       "that name exists (NB: prescribes unique disk names!)" do
+      "that name exists (NB: prescribes unique disk names!)" do
       q_results = [
         { :name => @disk_name, :href => @disk_id },
         { :name => @disk_name, :href => '12341234-1234-1234-1234-123456789012' },
@@ -87,7 +87,7 @@ describe Vcloud::Core::IndependentDisk do
       expect {
         Vcloud::Core::IndependentDisk.get_by_name_and_vdc_name(@disk_name, @vdc_name)
       }.to raise_exception(RuntimeError)
-    end
+      end
 
   end
 
@@ -192,16 +192,16 @@ describe Vcloud::Core::IndependentDisk do
 
     before(:each) {
       @stub_attrs = {
-        :name => @disk_name,
-        :href => "https://api.vcloud-director.example.com/api/disk/#{@disk_id}",
-        :Link => [{
-          :rel => 'up',
-          :type => 'application/vnd.vmware.vcloud.vdc+xml',
-          :href => 'https://api.vcloud-director.example.com/api/vdc/074aea1e-a5e9-4dd1-a028-40db8c98d237'
-        }]
-      }
-      allow_any_instance_of(StubFogInterface).to receive(:get_disk).and_return(@stub_attrs)
-      @disk = Vcloud::Core::IndependentDisk.new(@disk_id)
+      :name => @disk_name,
+      :href => "https://api.vcloud-director.example.com/api/disk/#{@disk_id}",
+      :Link => [{
+        :rel => 'up',
+        :type => 'application/vnd.vmware.vcloud.vdc+xml',
+        :href => 'https://api.vcloud-director.example.com/api/vdc/074aea1e-a5e9-4dd1-a028-40db8c98d237'
+      }]
+    }
+    allow_any_instance_of(StubFogInterface).to receive(:get_disk).and_return(@stub_attrs)
+    @disk = Vcloud::Core::IndependentDisk.new(@disk_id)
     }
 
     it { expect(@disk.name).to eq(@disk_name) }
@@ -225,9 +225,9 @@ describe Vcloud::Core::IndependentDisk do
       })
       expect(@mock_fog_interface).to receive(:get_vms_disk_attached_to).
         with(subject.id).and_return({:VmReference=>[
-          { :href => '/vm-12341234-1234-1234-1234-123412340001' },
-          { :href => '/vm-12341234-1234-1234-1234-123412340002' },
-        ]})
+                                    { :href => '/vm-12341234-1234-1234-1234-123412340001' },
+                                    { :href => '/vm-12341234-1234-1234-1234-123412340002' },
+      ]})
       vms = subject.attached_vms
       expect(vms[0].id).to eq('vm-12341234-1234-1234-1234-123412340001')
       expect(vms[1].id).to eq('vm-12341234-1234-1234-1234-123412340002')

data/spec/vcloud/core/metadata_helper_spec.rb

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

data/spec/vcloud/core/org_vdc_network_spec.rb

@@ -1,257 +1,253 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe OrgVdcNetwork do
+describe Vcloud::Core::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
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+    allow_any_instance_of(Vcloud::Core::Vdc).to receive(:id).and_return(@vdc_id)
+    @mock_vdc = double(:vdc, :id => @vdc_id)
+    allow(Vcloud::Core::Vdc).to receive(:get_by_name).and_return(@mock_vdc)
+  end
+
+  context "Class public interface" do
+    it { expect(Vcloud::Core::OrgVdcNetwork).to respond_to(:provision) }
+  end
+
+  context "Object public interface" do
+    subject { Vcloud::Core::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 = Vcloud::Core::OrgVdcNetwork.new(@net_id)
+      expect(obj.class).to be(Vcloud::Core::OrgVdcNetwork)
+    end
+
+    it "should store the id specified" do
+      obj = Vcloud::Core::OrgVdcNetwork.new(@net_id)
+      expect(obj.id).to eq(@net_id)
+    end
+
+    it "should raise error if id is not in correct format" do
+      bogus_id = '123123-bogus-id-123445'
+      expect{ Vcloud::Core::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
+      expect(@mock_fog_interface).to receive(:delete_network).with(@net_id)
+      Vcloud::Core::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
+      )
+      allow(Vcloud::Core::Vdc).to receive(:get_by_name).and_return(@mock_vdc)
+    end
+
+    context "should fail gracefully on bad input" 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
-        allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
-        allow_any_instance_of(Vdc).to receive(:id).and_return(@vdc_id)
-        @mock_vdc = double(:vdc, :id => @vdc_id)
-        allow(Vdc).to receive(:get_by_name).and_return(@mock_vdc)
+        @config = {
+          :name => @net_name,
+          :vdc_name => @vdc_name,
+          :fence_mode => 'isolated'
+        }
       end
 
-      context "Class public interface" do
-        it { expect(OrgVdcNetwork).to respond_to(:provision) }
+      it "should fail if :name is not set" do
+        @config.delete(:name)
+        expect { Vcloud::Core::OrgVdcNetwork.provision(@config) }.
+          to raise_exception(RuntimeError)
       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) }
+      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
 
-      context "#initialize" do
+      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 be constructable from just an id reference" do
-          obj = OrgVdcNetwork.new(@net_id)
-          expect(obj.class).to be(Vcloud::Core::OrgVdcNetwork)
-        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
 
-        it "should store the id specified" do
-          obj = OrgVdcNetwork.new(@net_id)
-          expect(obj.id).to eq(@net_id)
-        end
+    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
+    context "isolated orgVdcNetwork" do
 
+      before(:each) do
+        q_results = [
+          { :name => @net_name, :href => "/#{@net_id}" }
+        ]
+        @mock_net_query = double(:query_runner, :run => q_results)
+        @config = {
+          :name => @net_name,
+          :vdc_name => @vdc_name,
+          :fence_mode => 'isolated'
+        }
       end
 
-      context "#delete" do
-        it "should call down to Fog::ServiceInterface.delete_network with the correct id" do
-          expect(@mock_fog_interface).to receive(:delete_network).with(@net_id)
-          OrgVdcNetwork.new(@net_id).delete
-        end
+      it "should create an Vcloud::Core::OrgVdcNetwork with minimal config" do
+        expected_vcloud_attrs = {
+          :IsShared => false,
+          :Configuration => {
+          :FenceMode => 'isolated',
+          :IpScopes => {
+          :IpScope => {
+          :IsInherited => false,
+          :IsEnabled => true
+        }
+        }
+        },
+        }
+        expect(Vcloud::Core.logger).to receive(:info)
+        expect(@mock_fog_interface).to 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).to eq(@net_id)
       end
 
-      context "#provision" do
-
-        before(:each) do
-          @mock_vdc = double(
-            :vdc,
-            :id => @vdc_id,
-            :href => "/#{@vdc_id}",
-            :name => @vdc_name
-          )
-          allow(Vdc).to receive(: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_runner, :run => 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
-                  }
-                }
-              },
-            }
-            expect(Vcloud::Core.logger).to receive(:info)
-            expect(@mock_fog_interface).to 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).to eq(@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'
-                      },
-                    }],
-                  }
-                }
+      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'
+        },
+        }],
+        }
+        }
+        }
+        }
+        expect(Vcloud::Core.logger).to receive(:info)
+        expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
+          with(@vdc_id, @config[:name], expected_vcloud_attrs).
+          and_return({ :href => "/#{@net_id}" })
+        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'
             }
-            expect(Vcloud::Core.logger).to receive(:info)
-            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
-                with(@vdc_id, @config[:name], expected_vcloud_attrs).
-                and_return({ :href => "/#{@net_id}" })
-            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'
-                        }
-                      },
-                    ]
-                  }
-                }
-              },
-            }
-            expect(Vcloud::Core.logger).to receive(:info)
-            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
-                with(@vdc_id, @config[:name], expected_vcloud_attrs).
-                and_return({ :href => "/#{@net_id}" })
-            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)
-            allow(Vcloud::Core::EdgeGateway).to receive(: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}" },
-            }
-            expect(Vcloud::Core.logger).to receive(:info)
-            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
-                with(@vdc_id, @config[:name], expected_vcloud_attrs).
-                and_return({ :href => "/#{@net_id}" })
-            Vcloud::Core::OrgVdcNetwork.provision(@config)
-          end
+        },
+        ]
+        }
+        }
+        },
+        }
+        expect(Vcloud::Core.logger).to receive(:info)
+        expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
+          with(@vdc_id, @config[:name], expected_vcloud_attrs).
+          and_return({ :href => "/#{@net_id}" })
+        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
 
-        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)
+        allow(Vcloud::Core::EdgeGateway).to receive(: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}" },
+        }
+        expect(Vcloud::Core.logger).to receive(:info)
+        expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
+          with(@vdc_id, @config[:name], expected_vcloud_attrs).
+          and_return({ :href => "/#{@net_id}" })
+        Vcloud::Core::OrgVdcNetwork.provision(@config)
       end
 
     end
+
   end
+
 end