vcloud-core 1.0.0 → 1.0.1

data/spec/vcloud/core/edge_gateway_interface_spec.rb

@@ -1,87 +1,82 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe EdgeGatewayInterface do
-
-      before(:each) do
-        @valid_ext_id = "12345678-70ac-487e-9c1e-124716764274"
-        @gateway_interface_hash = {
-          :Name=>"EXTERNAL_NETWORK",
-          :Network=>{
-            :type=>"application/vnd.vmware.admin.network+xml",
-            :name=>"EXTERNAL_NETWORK",
-            :href=>"https://example.com/api/admin/network/#{@valid_ext_id}"
-          },
-          :InterfaceType=>"uplink",
-          :SubnetParticipation=>{
-            :Gateway=>"192.2.0.1",
-            :Netmask=>"255.255.255.0",
-            :IpAddress=>"192.2.0.66"
-          },
-          :UseForDefaultRoute=>"true"
-        }
-        @interface = EdgeGatewayInterface.new(@gateway_interface_hash)
-      end
-
-      context "Instance public interface" do
-        subject { EdgeGatewayInterface.new(@gateway_interface_hash) }
-        it { should respond_to(:name) }
-        it { should respond_to(:network_id) }
-        it { should respond_to(:network_name) }
-        it { should respond_to(:network_href) }
-      end
-
-      context "#initialize" do
+describe Vcloud::Core::EdgeGatewayInterface do
+
+  before(:each) do
+    @valid_ext_id = "12345678-70ac-487e-9c1e-124716764274"
+    @gateway_interface_hash = {
+      :Name=>"EXTERNAL_NETWORK",
+      :Network=>{
+      :type=>"application/vnd.vmware.admin.network+xml",
+      :name=>"EXTERNAL_NETWORK",
+      :href=>"https://example.com/api/admin/network/#{@valid_ext_id}"
+    },
+      :InterfaceType=>"uplink",
+      :SubnetParticipation=>{
+      :Gateway=>"192.2.0.1",
+      :Netmask=>"255.255.255.0",
+      :IpAddress=>"192.2.0.66"
+    },
+      :UseForDefaultRoute=>"true"
+    }
+    @interface = Vcloud::Core::EdgeGatewayInterface.new(@gateway_interface_hash)
+  end
 
-        it "should be constructable from just a Fog vCloud GatewayInterfaceType hash" do
-          obj = EdgeGatewayInterface.new(@gateway_interface_hash)
-          expect(obj.class).to be(Vcloud::Core::EdgeGatewayInterface)
-        end
+  context "Instance public interface" do
+    subject { Vcloud::Core::EdgeGatewayInterface.new(@gateway_interface_hash) }
+    it { should respond_to(:name) }
+    it { should respond_to(:network_id) }
+    it { should respond_to(:network_name) }
+    it { should respond_to(:network_href) }
+  end
 
-        it "should raise an error if passed a nil value" do
-          expect { EdgeGatewayInterface.new(nil) }.
-            to raise_error(StandardError, /^EdgeGatewayInterface:/)
-        end
+  context "#initialize" do
 
-        it "should raise an error if a :Name is not passed" do
-          expect { EdgeGatewayInterface.new({}) }.
-            to raise_error(StandardError, /^EdgeGatewayInterface:/)
-        end
+    it "should be constructable from just a Fog vCloud GatewayInterfaceType hash" do
+      obj = Vcloud::Core::EdgeGatewayInterface.new(@gateway_interface_hash)
+      expect(obj.class).to be(Vcloud::Core::EdgeGatewayInterface)
+    end
 
-        it "should raise an error if a :Network is not passed" do
-          expect { EdgeGatewayInterface.new({Name: 'test-interface'}) }.
-            to raise_error(StandardError, /^EdgeGatewayInterface:/)
-        end
+    it "should raise an error if passed a nil value" do
+      expect { Vcloud::Core::EdgeGatewayInterface.new(nil) }.
+        to raise_error(StandardError, /^EdgeGatewayInterface:/)
+    end
 
-      end
+    it "should raise an error if a :Name is not passed" do
+      expect { Vcloud::Core::EdgeGatewayInterface.new({}) }.
+        to raise_error(StandardError, /^EdgeGatewayInterface:/)
+    end
 
-      context "#name" do
-        it "should return the name of the interface" do
-          expect(@interface.name).to eq('EXTERNAL_NETWORK')
-        end
-      end
+    it "should raise an error if a :Network is not passed" do
+      expect { Vcloud::Core::EdgeGatewayInterface.new({Name: 'test-interface'}) }.
+        to raise_error(StandardError, /^EdgeGatewayInterface:/)
+    end
 
-      context "#network_id" do
-        it "should return the id of the network the interface is connected to" do
-          expect(@interface.network_id).to eq(@valid_ext_id)
-        end
-      end
+  end
 
-      context "#network_name" do
-        it "should return the name of the network the interface is connected to" do
-          expect(@interface.network_name).to eq('EXTERNAL_NETWORK')
-        end
-      end
+  context "#name" do
+    it "should return the name of the interface" do
+      expect(@interface.name).to eq('EXTERNAL_NETWORK')
+    end
+  end
 
-      context "#network_href" do
-        it "should return the href of the network the interface is connected to" do
-          expect(@interface.network_href).to eq("https://example.com/api/admin/network/#{@valid_ext_id}")
-        end
-      end
+  context "#network_id" do
+    it "should return the id of the network the interface is connected to" do
+      expect(@interface.network_id).to eq(@valid_ext_id)
+    end
+  end
 
+  context "#network_name" do
+    it "should return the name of the network the interface is connected to" do
+      expect(@interface.network_name).to eq('EXTERNAL_NETWORK')
     end
+  end
 
+  context "#network_href" do
+    it "should return the href of the network the interface is connected to" do
+      expect(@interface.network_href).to eq("https://example.com/api/admin/network/#{@valid_ext_id}")
+    end
   end
 
 end
+

data/spec/vcloud/core/edge_gateway_spec.rb

@@ -1,163 +1,157 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe EdgeGateway do
-
-      before(:each) do
-        @edgegw_id = '12345678-1234-1234-1234-000000111454'
-        @mock_fog_interface = StubFogInterface.new
-        allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
-      end
+describe Vcloud::Core::EdgeGateway do
 
-      context "Class public interface" do
-        it { expect(EdgeGateway).to respond_to(:get_ids_by_name) }
-        it { expect(EdgeGateway).to respond_to(:get_by_name) }
-      end
+  before(:each) do
+    @edgegw_id = '12345678-1234-1234-1234-000000111454'
+    @mock_fog_interface = StubFogInterface.new
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+  end
 
-      context "Instance public interface" do
-        subject { EdgeGateway.new(@edgegw_id) }
-        it { should respond_to(:id) }
-        it { should respond_to(:name) }
-        it { should respond_to(:href) }
-        it { should respond_to(:vcloud_gateway_interface_by_id) }
-      end
+  context "Class public interface" do
+    it { expect(Vcloud::Core::EdgeGateway).to respond_to(:get_ids_by_name) }
+    it { expect(Vcloud::Core::EdgeGateway).to respond_to(:get_by_name) }
+  end
 
-      context "#initialize" do
+  context "Instance public interface" do
+    subject { Vcloud::Core::EdgeGateway.new(@edgegw_id) }
+    it { should respond_to(:id) }
+    it { should respond_to(:name) }
+    it { should respond_to(:href) }
+    it { should respond_to(:vcloud_gateway_interface_by_id) }
+  end
 
-        it "should be constructable from just an id reference" do
-          obj = EdgeGateway.new(@edgegw_id)
-          expect(obj.class).to be(Vcloud::Core::EdgeGateway)
-        end
+  context "#initialize" do
 
-        it "should store the id specified" do
-          obj = EdgeGateway.new(@edgegw_id)
-          expect(obj.id).to eq(@edgegw_id)
-        end
+    it "should be constructable from just an id reference" do
+      obj = Vcloud::Core::EdgeGateway.new(@edgegw_id)
+      expect(obj.class).to be(Vcloud::Core::EdgeGateway)
+    end
 
-        it "should raise error if id is not in correct format" do
-          bogus_id = '123123-bogus-id-123445'
-          expect{ EdgeGateway.new(bogus_id) }.to raise_error("EdgeGateway id : #{bogus_id} is not in correct format" )
-        end
+    it "should store the id specified" do
+      obj = Vcloud::Core::EdgeGateway.new(@edgegw_id)
+      expect(obj.id).to eq(@edgegw_id)
+    end
 
-      end
+    it "should raise error if id is not in correct format" do
+      bogus_id = '123123-bogus-id-123445'
+      expect{ Vcloud::Core::EdgeGateway.new(bogus_id) }.to raise_error("EdgeGateway id : #{bogus_id} is not in correct format" )
+    end
 
-      context "#get_by_name" do
+  end
 
-        it "should return a EdgeGateway object if name exists" do
-          q_results = [
-            { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
-          ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
-          @obj = EdgeGateway.get_by_name('edgegw-test-1')
-          expect(@obj.class).to be(Vcloud::Core::EdgeGateway)
-        end
-
-        it "should return an object with the correct id if name exists" do
-          q_results = [
-            { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
+  context "#get_by_name" do
+
+    it "should return a Vcloud::Core::EdgeGateway object if name exists" do
+      q_results = [
+        { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
+      ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
+      @obj = Vcloud::Core::EdgeGateway.get_by_name('edgegw-test-1')
+      expect(@obj.class).to be(Vcloud::Core::EdgeGateway)
+    end
+
+    it "should return an object with the correct id if name exists" do
+      q_results = [
+        { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
+      ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
+      @obj = Vcloud::Core::EdgeGateway.get_by_name('edgegw-test-1')
+      expect(@obj.id).to eq(@edgegw_id)
+    end
+
+    it "should raise an error if no edgegw with that name exists" do
+      q_results = [ ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
+      expect{ Vcloud::Core::EdgeGateway.get_by_name('edgegw-test-1') }.to raise_exception(RuntimeError, "edgeGateway edgegw-test-1 not found")
+    end
+
+  end
+
+  context "Interface related tests" do
+
+    before(:each) do
+      @valid_ext_id = "12345678-70ac-487e-9c1e-124716764274"
+      @valid_int_id = "12345678-70ac-487e-9c1e-552f1f0a91dc"
+      edge_gateway_hash = {
+        :Configuration=>
+        {:GatewayBackingConfig=>"compact",
+          :GatewayInterfaces=>
+        {:GatewayInterface=>
+          [{:Name=>"EXTERNAL_NETWORK",
+            :Network=>
+          {:type=>"application/vnd.vmware.admin.network+xml",
+            :name=>"EXTERNAL_NETWORK",
+            :href=>
+          "https://example.com/api/admin/network/#{@valid_ext_id}"},
+          :InterfaceType=>"uplink",
+            :SubnetParticipation=>
+          {:Gateway=>"192.2.0.1",
+            :Netmask=>"255.255.255.0",
+            :IpAddress=>"192.2.0.66"},
+            :UseForDefaultRoute=>"true"},
+            {:Name=>"INTERNAL_NETWORK",
+              :Network=>
+          {:type=>"application/vnd.vmware.admin.network+xml",
+            :name=>"INTERNAL_NETWORK",
+            :href=>
+          "https://example.com/api/admin/network/#{@valid_int_id}"},
+          :InterfaceType=>"internal",
+            :SubnetParticipation=>
+          {:Gateway=>"192.168.1.1",
+            :Netmask=>"255.255.255.0",
+            :IpAddress=>"192.168.1.55"},
+            :UseForDefaultRoute=>"false"
+          },
           ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
-          @obj = EdgeGateway.get_by_name('edgegw-test-1')
-          expect(@obj.id).to eq(@edgegw_id)
-        end
-
-        it "should raise an error if no edgegw with that name exists" do
-          q_results = [ ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
-          expect{ EdgeGateway.get_by_name('edgegw-test-1') }.to raise_exception(RuntimeError, "edgeGateway edgegw-test-1 not found")
-        end
+        }
+        }
+      }
+      expect(@mock_fog_interface).to receive(:get_edge_gateway).
+        and_return(edge_gateway_hash)
+      @edgegw = Vcloud::Core::EdgeGateway.new(@edgegw_id)
+    end
+
+    context "#vcloud_gateway_interface_by_id" do
 
+      it "should return nil if the network id is not found" do
+        expect(@edgegw.vcloud_gateway_interface_by_id(
+          '12345678-1234-1234-1234-123456789012')).
+          to be_nil
       end
 
-      context "Interface related tests" do
-
-        before(:each) do
-          @valid_ext_id = "12345678-70ac-487e-9c1e-124716764274"
-          @valid_int_id = "12345678-70ac-487e-9c1e-552f1f0a91dc"
-          edge_gateway_hash = {
-            :Configuration=>
-              {:GatewayBackingConfig=>"compact",
-               :GatewayInterfaces=>
-                {:GatewayInterface=>
-                  [{:Name=>"EXTERNAL_NETWORK",
-                    :Network=>
-                     {:type=>"application/vnd.vmware.admin.network+xml",
-                      :name=>"EXTERNAL_NETWORK",
-                      :href=>
-                       "https://example.com/api/admin/network/#{@valid_ext_id}"},
-                    :InterfaceType=>"uplink",
-                    :SubnetParticipation=>
-                     {:Gateway=>"192.2.0.1",
-                      :Netmask=>"255.255.255.0",
-                      :IpAddress=>"192.2.0.66"},
-                    :UseForDefaultRoute=>"true"},
-                   {:Name=>"INTERNAL_NETWORK",
-                    :Network=>
-                     {:type=>"application/vnd.vmware.admin.network+xml",
-                      :name=>"INTERNAL_NETWORK",
-                      :href=>
-                       "https://example.com/api/admin/network/#{@valid_int_id}"},
-                    :InterfaceType=>"internal",
-                    :SubnetParticipation=>
-                     {:Gateway=>"192.168.1.1",
-                      :Netmask=>"255.255.255.0",
-                      :IpAddress=>"192.168.1.55"},
-                    :UseForDefaultRoute=>"false"
-                   },
-                  ]
-                }
-              }
-          }
-          expect(@mock_fog_interface).to receive(:get_edge_gateway).
-            and_return(edge_gateway_hash)
-          @edgegw = EdgeGateway.new(@edgegw_id)
-        end
-
-        context "#vcloud_gateway_interface_by_id" do
-
-          it "should return nil if the network id is not found" do
-            expect(@edgegw.vcloud_gateway_interface_by_id(
-                 '12345678-1234-1234-1234-123456789012')).
-              to be_nil
-          end
-
-          it "should return a vcloud network hash if the network id is found" do
-            expect(@edgegw.vcloud_gateway_interface_by_id(@valid_int_id)).
-              to eq(
-                     {:Name=>"INTERNAL_NETWORK",
-                      :Network=>
-                       {:type=>"application/vnd.vmware.admin.network+xml",
-                        :name=>"INTERNAL_NETWORK",
-                        :href=>
-                         "https://example.com/api/admin/network/#{@valid_int_id}"},
-                      :InterfaceType=>"internal",
-                      :SubnetParticipation=>
-                       {:Gateway=>"192.168.1.1",
-                        :Netmask=>"255.255.255.0",
-                        :IpAddress=>"192.168.1.55"},
-                      :UseForDefaultRoute=>"false"
-                     },
-                   )
-          end
-        end
-
-        context "#interfaces" do
-
-          it "should return an array of EdgeGatewayInterface objects" do
-            interfaces_list = @edgegw.interfaces
-            expect(interfaces_list.class).to be(Array)
-            expect(interfaces_list.first.class).to be(Vcloud::Core::EdgeGatewayInterface)
-          end
-
-        end
+      it "should return a vcloud network hash if the network id is found" do
+        expect(@edgegw.vcloud_gateway_interface_by_id(@valid_int_id)).
+          to eq(
+            {:Name=>"INTERNAL_NETWORK",
+              :Network=>
+        {:type=>"application/vnd.vmware.admin.network+xml",
+          :name=>"INTERNAL_NETWORK",
+          :href=>
+        "https://example.com/api/admin/network/#{@valid_int_id}"},
+        :InterfaceType=>"internal",
+          :SubnetParticipation=>
+        {:Gateway=>"192.168.1.1",
+          :Netmask=>"255.255.255.0",
+          :IpAddress=>"192.168.1.55"},
+          :UseForDefaultRoute=>"false"
+        },
+        )
+      end
+    end
+
+    context "#interfaces" do
 
+      it "should return an array of Vcloud::Core::EdgeGatewayInterface objects" do
+        interfaces_list = @edgegw.interfaces
+        expect(interfaces_list.class).to be(Array)
+        expect(interfaces_list.first.class).to be(Vcloud::Core::EdgeGatewayInterface)
       end
 
     end