fog 0.3.16 → 0.3.17

data/lib/fog/rackspace/requests/cdn/{head_cdn_container.rb → head_container.rb}

@@ -1,6 +1,6 @@
 module Fog
   module Rackspace
-    class Storage
+    class CDN
       class Real
 
         # List cdn properties for a container
@@ -17,7 +17,7 @@ module Fog
         #     * 'X-Log-Retention'<~Boolean> - ?
         #     * 'X-User-Agent-ACL'<~String> - ?
         #     * 'X-Referrer-ACL'<~String> - ?
-        def head_cdn_container(container)
+        def head_container(container)
           response = request(
             :expects  => 204,
             :method   => 'HEAD',
@@ -31,7 +31,7 @@ module Fog
 
       class Mock
 
-        def head_cdn_container(container)
+        def head_container(container)
           Fog::Mock.not_implemented
         end
 

data/lib/fog/rackspace/requests/cdn/{put_cdn_container.rb → put_container.rb}

@@ -1,6 +1,6 @@
 module Fog
   module Rackspace
-    class Storage
+    class CDN
       class Real
 
         # modify CDN properties for a container
@@ -14,7 +14,7 @@ module Fog
         #   * 'X-Log-Retention'<~Boolean> - ?
         #   * 'X-User-Agent-ACL'<~String> - ?
         #   * 'X-Referrer-ACL'<~String> - ?
-        def put_cdn_container(name, options = {})
+        def put_container(name, options = {})
           response = request(
             :expects  => [201, 202],
             :headers  => options,
@@ -28,7 +28,7 @@ module Fog
 
       class Mock
 
-        def put_cdn_container(name, options = {})
+        def put_container(name, options = {})
           Fog::Mock.not_implemented
         end
 

data/lib/fog/rackspace/storage.rb

@@ -24,6 +24,13 @@ module Fog
 
       module Utils
 
+        def cdn
+          @cdn ||= Fog::Rackspace::CDN.new(
+            :rackspace_api_key => @rackspace_api_key,
+            :rackspace_username => @rackspace_username
+          )
+        end
+
         def parse_data(data)
           metadata = {
             :body => nil,
@@ -64,6 +71,7 @@ module Fog
 
         def initialize(options={})
           require 'mime/types'
+          @rackspace_api_key = options[:rackspace_api_key]
           @rackspace_username = options[:rackspace_username]
           @data = self.class.data[@rackspace_username]
         end
@@ -76,6 +84,8 @@ module Fog
         def initialize(options={})
           require 'mime/types'
           require 'json'
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
           credentials = Fog::Rackspace.authenticate(options)
           @auth_token = credentials['X-Auth-Token']
 

data/lib/fog/vcloud.rb

@@ -5,6 +5,7 @@ require 'builder'
 require 'fog/vcloud/model'
 require 'fog/vcloud/collection'
 require 'fog/vcloud/generators'
+require 'fog/vcloud/mock_data_classes'
 # ecloud/vcloud requires at the bottom so that the following will be defined
 
 module URI
@@ -249,6 +250,7 @@ module Fog
 
     class Mock
       include Shared
+      include MockDataClasses
 
       def self.base_url
         "https://fakey.com/api/v0.8"
@@ -259,159 +261,36 @@ module Fog
       end
 
       def self.data( base_url = self.base_url )
-        @mock_data ||=
-        {
-          :versions => [
-            { :version => "v0.8", :login_url => "#{base_url}/login", :supported => true }
-          ],
-          :vdc_resources => [
-            {
-              :type => "application/vnd.vmware.vcloud.vApp+xml",
-              :href => "#{base_url}/vapp/61",
-              :name => "Foo App 1"
-            },
-            {
-              :type => "application/vnd.vmware.vcloud.vApp+xml",
-              :href => "#{base_url}/vapp/62",
-              :name => "Bar App 1"
-            },
-            {
-              :type => "application/vnd.vmware.vcloud.vApp+xml",
-              :href => "#{base_url}/vapp/63",
-              :name => "Bar App 2"
-            }
-          ],
-          :organizations =>
-          [
-            {
-              :info => {
-                :href => "#{base_url}/org/1",
-                :name => "Boom Inc.",
-              },
-              :vdcs => [
-
-                { :href => "#{base_url}/vdc/21",
-                  :id => "21",
-                  :name => "Boomstick",
-                  :storage => { :used => "105", :allocated => "200" },
-                  :cpu => { :allocated => "10000" },
-                  :memory => { :allocated => "20480" },
-                  :catalog => {
-                     :name => "The catalog",
-                     :items => [
-                        { :id => "0", :name => "Item 0", :disks => [{ :size => 25 }] },
-                        { :id => "1", :name => "Item 1" },
-                        { :id => "2", :name => "Item 2" },
-                     ]
-                  },
-                  :networks => [
-                    { :id => "31",
-                      :href => "#{base_url}/network/31",
-                      :name => "1.2.3.0/24",
-                      :subnet => "1.2.3.0/24",
-                      :gateway => "1.2.3.1",
-                      :netmask => "255.255.255.0",
-                      :dns => "8.8.8.8",
-                      :features => [
-                        { :type => :FenceMode, :value => "isolated" }
-                      ],
-                      :ips => { "1.2.3.3" => "Broom 1", "1.2.3.4" => "Broom 2", "1.2.3.10" => "Email" }
-                    },
-                    { :id => "32",
-                      :href => "#{base_url}/network/32",
-                      :name => "4.5.6.0/24",
-                      :subnet => "4.5.6.0/24",
-                      :gateway => "4.5.6.1",
-                      :netmask => "255.255.255.0",
-                      :dns => "8.8.8.8",
-                      :features => [
-                        { :type => :FenceMode, :value => "isolated" }
-                      ],
-                      :ips => { }
-                    },
-                  ],
-                  :vms => [
-                    { :href => "#{base_url}/vapp/41",
-                      :name => "Broom 1",
-                      :ip   => "1.2.3.3",
-                      :memory => 1024,
-                      :cpus => 1,
-                      :disks => [{ :size => 25 }],
-                      :status => 2
-                    },
-                    { :href => "#{base_url}/vapp/42",
-                      :name => "Broom 2",
-                      :ip => "1.2.3.4"
-                    },
-                    { :href => "#{base_url}/vapp/43",
-                      :name => "Email!"
-                    }
-                  ]
-                },
-                { :href => "#{base_url}/vdc/22",
-                  :id => "22",
-                  :storage => { :used => "40", :allocated => "150" },
-                  :cpu => { :allocated => "1000" },
-                  :memory => { :allocated => "2048" },
-                  :name => "Rock-n-Roll",
-                  :networks => [
-                    { :id => "33",
-                      :href => "#{base_url}/network/33",
-                      :name => "7.8.9.0/24",
-                      :subnet => "7.8.9.0/24",
-                      :gateway => "7.8.9.1",
-                      :dns => "8.8.8.8",
-                      :netmask => "255.255.255.0",
-                      :features => [
-                        { :type => :FenceMode, :value => "isolated" }
-                      ],
-                      :ips => { "7.8.9.10" => "Master Blaster" }
-                    }
-                  ],
-                  :vms => [
-                    { :href => "#{base_url}/vapp/44",
-                      :name => "Master Blaster"
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      end
-
-      def vdc_from_uri(uri)
-        match = Regexp.new(%r:.*/vdc/(\d+):).match(uri.to_s)
-        match && vdc_from_id(match[1])
-      end
-
-      def vdc_from_id(id)
-        mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:id] == id }
-      end
-
-      def ip_from_uri(uri)
-        match = Regexp.new(%r:.*/publicIp/(\d+):).match(uri.to_s)
-        if match
-          mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |public_ip| public_ip[:id] == match[1] }
-        end
-      end
-
-      def vapp_and_vdc_from_vapp_uri(uri)
-        if vdc = mock_data[:organizations].map {|o| o[:vdcs] }.flatten.detect {|vd| vd[:vms].detect {|vm| uri =~ %r{^#{Regexp.escape(vm[:href])}($|/)} } }
-          vapp = vdc[:vms].detect {|v| uri =~ %r{^#{Regexp.escape(v[:href])}($|/)} }
-          if vapp
-            [vapp, vdc]
-          end
-        end
-      end
-
-      def catalog_item_and_vdc_from_catalog_item_uri(uri)
-        catalog_item_id, vdc_id = uri.split("/").last.split("-")
-        vdc = vdc_from_id(vdc_id)
-        if vdc
-          catalog_item = vdc[:catalog][:items].detect {|ci| ci[:id] == catalog_item_id }
-          if catalog_item
-            [catalog_item, vdc]
+        MockDataClasses::Base.base_url = base_url
+
+        @mock_data ||= MockData.new.tap do |mock_data|
+          mock_data.versions << MockVersion.new(:version => "v0.8", :supported => true)
+
+          mock_data.organizations << MockOrganization.new(:name => "Boom Inc.").tap do |mock_organization|
+            mock_organization.vdcs << MockVdc.new(:name => "Boomstick").tap do |mock_vdc|
+              mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 0").tap do |mock_catalog_item|
+                mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
+              end
+              mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 1").tap do |mock_catalog_item|
+                mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
+              end
+              mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 2").tap do |mock_catalog_item|
+                mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
+              end
+
+              mock_vdc.networks << MockNetwork.new({ :subnet => "1.2.3.0/24" }, mock_vdc)
+              mock_vdc.networks << MockNetwork.new({ :subnet => "4.5.6.0/24" }, mock_vdc)
+
+              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Broom 1", :ip => "1.2.3.3" }, mock_vdc)
+              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Broom 2", :ip => "1.2.3.4" }, mock_vdc)
+              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Email!", :ip => "1.2.3.10" }, mock_vdc)
+            end
+
+            mock_organization.vdcs << MockVdc.new(:name => "Rock-n-Roll", :storage_allocated => 150, :storage_used => 40, :cpu_allocated => 1000, :memory_allocated => 2048).tap do |mock_vdc|
+              mock_vdc.networks << MockNetwork.new({ :subnet => "7.8.9.0/24" }, mock_vdc)
+
+              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Master Blaster", :ip => "7.8.9.10" }, mock_vdc)
+            end
           end
         end
       end

data/lib/fog/vcloud/collection.rb

@@ -7,6 +7,24 @@ module Fog
         super
       end
 
+      def check_href!(opts = {})
+        unless href
+          if opts.is_a?(String)
+            t = Hash.new
+            t[:parent] = opts
+            opts = t
+          end
+          msg = ":href missing, call with a :href pointing to #{if opts[:message]
+                  opts[:message]
+                elsif opts[:parent]
+                  "the #{opts[:parent]} whos #{self.class.to_s.split('::').last.downcase} you want to enumerate"
+                else
+                  "the resource"
+                end}"
+          raise Fog::Errors::Error.new(msg)
+        end
+      end
+
     end
   end
 end

data/lib/fog/vcloud/mock_data_classes.rb

@@ -0,0 +1,701 @@
+require "ipaddr"
+
+class IPAddr
+  def mask
+    _to_string(@mask_addr)
+  end
+end
+
+module Fog
+  class Vcloud
+    module MockDataClasses
+      class Base < Hash
+        def self.base_url=(url)
+          @base_url = url
+        end
+
+        self.base_url = "http://vcloud.example.com"
+
+        def self.base_url
+          @base_url
+        end
+
+        def first
+          raise "Don't do this"
+        end
+
+        def last
+          raise "Don't do this"
+        end
+
+        def initialize(data = {}, parent = nil)
+          @parent = parent
+
+          replace(data)
+        end
+
+        def _parent
+          @parent
+        end
+
+        def base_url
+          Base.base_url
+        end
+
+        def href
+          [base_url, self.class.name.split("::").last, object_id].join("/")
+        end
+
+        def inspect
+          "<#{self.class.name} #{object_id} data=#{super} method_data=#{method_data.inspect}>"
+        end
+
+        private
+
+        def unique_methods
+          (public_methods - self.class.superclass.public_instance_methods).reject {|m| m.to_s =~ /!$/ }
+        end
+
+        def method_data
+          (unique_methods + [:href]).sort_by(&:to_s).find_all {|m| method(m).arity == 0 }.inject({}) {|md, m| md.update(m => send(m)) }
+        end
+      end
+
+      class MockData < Base
+        def versions
+          @versions ||= []
+        end
+
+        def organizations
+          @organizations ||= []
+        end
+
+        def organization_from_href(href)
+          find_href_in(href, organizations)
+        end
+
+        def all_vdcs
+          organizations.map(&:vdcs).flatten
+        end
+
+        def vdc_from_href(href)
+          find_href_in(href, all_vdcs)
+        end
+
+        def all_catalogs
+          all_vdcs.map(&:catalog).flatten
+        end
+
+        def catalog_from_href(href)
+          find_href_in(href, all_catalogs)
+        end
+
+        def all_catalog_items
+          all_catalogs.map(&:items).flatten
+        end
+
+        def catalog_item_from_href(href)
+          find_href_in(href, all_catalog_items)
+        end
+
+        def all_virtual_machines
+          all_vdcs.map(&:virtual_machines).flatten
+        end
+
+        def virtual_machine_from_href(href)
+          find_href_prefixed_in(href, all_virtual_machines)
+        end
+
+
+        def all_networks
+          all_vdcs.map(&:networks).flatten
+        end
+
+        def network_from_href(href)
+          find_href_in(href, all_networks)
+        end
+
+        def all_network_extensions
+          all_networks.map(&:extensions).flatten
+        end
+
+        def network_extension_from_href(href)
+          find_href_in(href, all_network_extensions)
+        end
+
+        def all_vdc_internet_service_collections
+          all_vdcs.map(&:internet_service_collection).flatten
+        end
+
+        def vdc_internet_service_collection_from_href(href)
+          find_href_in(href, all_vdc_internet_service_collections)
+        end
+
+        def all_public_ip_collections
+          all_vdcs.map {|v| v.public_ip_collection }.flatten
+        end
+
+        def public_ip_collection_from_href(href)
+          find_href_in(href, all_public_ip_collections)
+        end
+
+        def all_public_ips
+          all_public_ip_collections.map(&:items).flatten
+        end
+
+        def public_ip_from_href(href)
+          find_href_in(href, all_public_ips)
+        end
+
+        def all_public_ip_internet_service_collections
+          all_public_ips.map(&:internet_service_collection).flatten
+        end
+
+        def public_ip_internet_service_collection_from_href(href)
+          find_href_in(href, all_public_ip_internet_service_collections)
+        end
+
+        def all_public_ip_internet_services
+          all_public_ip_internet_service_collections.map(&:items).flatten
+        end
+
+        def public_ip_internet_service_from_href(href)
+          find_href_in(href, all_public_ip_internet_services)
+        end
+
+        def all_public_ip_internet_service_node_collections
+          all_public_ip_internet_services.map(&:node_collection).flatten
+        end
+
+        def public_ip_internet_service_node_collection_from_href(href)
+          find_href_in(href, all_public_ip_internet_service_node_collections)
+        end
+
+        def all_public_ip_internet_service_nodes
+          all_public_ip_internet_service_node_collections.map(&:items).flatten
+        end
+
+        def public_ip_internet_service_node_from_href(href)
+          find_href_in(href, all_public_ip_internet_service_nodes)
+        end
+
+        def all_network_ip_collections
+          all_networks.map(&:ip_collection)
+        end
+
+        def network_ip_collection_from_href(href)
+          find_href_in(href, all_network_ip_collections)
+        end
+
+        def all_network_ips
+          all_network_ip_collections.map {|c| c.items.values }.flatten
+        end
+
+        def network_ip_from_href(href)
+          find_href_in(href, all_network_ips)
+        end
+
+        private
+
+        def find_href_in(href, objects)
+          objects.detect {|o| o.href == href }
+        end
+
+        def find_href_prefixed_in(href, objects)
+          objects.detect {|o| href =~ %r{^#{o.href}($|/)} }
+        end
+      end
+
+      class MockVersion < Base
+        def version
+          self[:version]
+        end
+
+        def supported
+          !!self[:supported]
+        end
+
+        def login_url
+          href
+        end
+      end
+
+      class MockOrganization < Base
+        def name
+          self[:name]
+        end
+
+        def vdcs
+          @vdcs ||= []
+        end
+      end
+
+      class MockVdc < Base
+        def name
+          self[:name]
+        end
+
+        def storage_allocated
+          self[:storage_allocated] || 200
+        end
+
+        def storage_used
+          self[:storage_used] || 105
+        end
+
+        def cpu_allocated
+          self[:cpu_allocated] || 10000
+        end
+
+        def memory_allocated
+          self[:memory_allocated] || 20480
+        end
+
+        def catalog
+          @catalog ||= MockCatalog.new({}, self)
+        end
+
+        def networks
+          @networks ||= []
+        end
+
+        def virtual_machines
+          @virtual_machines ||= []
+        end
+
+        def task_list
+          @task_list ||= MockTaskList.new({}, self)
+        end
+
+        # for TM eCloud, should probably be subclassed
+        def public_ip_collection
+          @public_ip_collection ||= MockPublicIps.new({}, self)
+        end
+
+        def internet_service_collection
+          @internet_service_collection ||= MockVdcInternetServices.new({}, self)
+        end
+
+        def firewall_acls
+          @firewall_acls ||= MockFirewallAcls.new({}, self)
+        end
+      end
+
+      class MockTaskList < Base
+        def name
+          self[:name] || "Tasks List"
+        end
+      end
+
+      class MockCatalog < Base
+        def name
+          self[:name] || "Catalog"
+        end
+
+        def items
+          @items ||= []
+        end
+      end
+
+      class MockCatalogItem < Base
+        def name
+          self[:name]
+        end
+
+        def disks
+          @disks ||= MockVirtualMachineDisks.new(self)
+        end
+
+        def customization
+          @customization ||= MockCatalogItemCustomization.new({}, self)
+        end
+
+        def vapp_template
+          @vapp_template ||= MockCatalogItemVappTemplate.new({ :name => name }, self)
+        end
+      end
+
+      class MockCatalogItemCustomization < Base
+        def name
+          self[:name] || "Customization Options"
+        end
+      end
+
+      class MockCatalogItemVappTemplate < Base
+        def name
+          self[:name]
+        end
+      end
+
+      class MockNetwork < Base
+        def name
+          self[:name] || subnet
+        end
+
+        def subnet
+          self[:subnet]
+        end
+
+        def gateway
+          self[:gateway] || subnet_ips[1]
+        end
+
+        def netmask
+          self[:netmask] || subnet_ipaddr.mask
+        end
+
+        def dns
+          "8.8.8.8"
+        end
+
+        def features
+          [
+           { :type => :FenceMode, :value => "isolated" }
+          ]
+        end
+
+        def ip_collection
+          @ip_collection ||= MockNetworkIps.new({}, self)
+        end
+
+        def extensions
+          @extensions ||= MockNetworkExtensions.new({}, self)
+        end
+
+        def random_ip
+          usable_subnet_ips[rand(usable_subnet_ips.length)]
+        end
+
+        # for TM eCloud. should probably be a subclass
+        def rnat
+          self[:rnat]
+        end
+
+        def usable_subnet_ips
+          subnet_ips[3..-2]
+        end
+
+        def address
+          subnet_ips.first
+        end
+
+        def broadcast
+          subnet_ips.last
+        end
+
+        private
+
+        def subnet_ipaddr
+          @ipaddr ||= IPAddr.new(subnet)
+        end
+
+        def subnet_ips
+          subnet_ipaddr.to_range.to_a.map(&:to_s)
+        end
+      end
+
+      class MockNetworkIps < Base
+        def items
+          @items ||= _parent.usable_subnet_ips.inject({}) do |out, subnet_ip|
+            out.update(subnet_ip => MockNetworkIp.new({ :ip => subnet_ip }, self))
+          end
+        end
+
+        def ordered_ips
+          items.values.sort_by {|i| i.ip.split(".").map(&:to_i) }
+        end
+
+        def name
+          "IP Addresses"
+        end
+      end
+
+      class MockNetworkIp < Base
+        def name
+          self[:name] || ip
+        end
+
+        def ip
+          self[:ip]
+        end
+
+        def used_by
+          self[:used_by] || _parent._parent._parent.virtual_machines.detect {|v| v.ip == ip }
+        end
+
+        def status
+          if used_by
+            "Assigned"
+          else
+            "Available"
+          end
+        end
+
+        def rnat
+          self[:rnat] || _parent._parent.rnat
+        end
+      end
+
+      class MockNetworkExtensions < Base
+        def name
+          _parent.name
+        end
+
+        def gateway
+          _parent.gateway
+        end
+
+        def broadcast
+          _parent.broadcast
+        end
+
+        def address
+          _parent.address
+        end
+
+        def rnat
+          _parent.rnat
+        end
+      end
+
+      class MockVirtualMachine < Base
+        def name
+          self[:name]
+        end
+
+        def ip
+          self[:ip]
+        end
+
+        def cpus
+          self[:cpus] || 1
+        end
+
+        def memory
+          self[:memory] || 1024
+        end
+
+        def disks
+          @disks ||= MockVirtualMachineDisks.new(self)
+        end
+
+        def status
+          self[:status] || 2
+        end
+
+        def power_off!
+          self[:status] = 2
+        end
+
+        def power_on!
+          self[:status] = 4
+        end
+
+        def size
+          disks.inject(0) {|s, d| s + d.vcloud_size }
+        end
+
+        # from fog ecloud server's _compose_vapp_data
+        def to_configure_vapp_hash
+          {
+            :name   => name,
+            :cpus   => cpus,
+            :memory => memory,
+            :disks  => disks.map {|d| { :number => d.address.to_s, :size => d.vcloud_size, :resource => d.vcloud_size.to_s } }
+          }
+        end
+
+        def href(purpose = :base)
+          case purpose
+          when :base
+            super()
+          when :power_on
+            super() + "/power/action/powerOn"
+          when :power_off
+            super() + "/power/action/powerOff"
+          end
+        end
+      end
+
+      class MockVirtualMachineDisks < Array
+        def initialize(parent = nil)
+          @parent = parent
+        end
+
+        def _parent
+          @parent
+        end
+
+        def <<(disk)
+          next_address = 0
+          disk_with_max_address = max {|a, b| a[:address] <=> b[:address] }
+          disk_with_max_address && next_address = disk_with_max_address.address + 1
+          disk[:address] ||= next_address
+
+          super(disk)
+
+          if (addresses = map {|d| d.address }).uniq.size != size
+            raise "Duplicate disk address in: #{addresses.inspect} (#{size})"
+          end
+
+          sort! {|a, b| a.address <=> b.address }
+          self
+        end
+
+        def at_address(address)
+          detect {|d| d.address == address }
+        end
+      end
+
+      class MockVirtualMachineDisk < Base
+        def size
+          self[:size].to_i
+        end
+
+        def vcloud_size
+          # kilobytes
+          size * 1024
+        end
+
+        def address
+          self[:address].to_i
+        end
+      end
+
+      # for Terremark eCloud
+
+      class MockVdcInternetServices < Base
+        def href
+          _parent.href + "/internetServices"
+        end
+
+        def name
+          "Internet Services"
+        end
+
+        def items
+          _parent.public_ip_collection.items.inject([]) do |services, public_ip|
+            services + public_ip.internet_service_collection.items
+          end
+        end
+      end
+
+      class MockFirewallAcls < Base
+        def name
+          "Firewall Access List"
+        end
+      end
+
+      class MockPublicIps < Base
+        def name
+          self[:name] || "Public IPs"
+        end
+
+        def items
+          @items ||= []
+        end
+      end
+
+      class MockPublicIp < Base
+        def name
+          self[:name]
+        end
+
+        def internet_service_collection
+          @internet_service_collection ||= MockPublicIpInternetServices.new({}, self)
+        end
+      end
+
+      class MockPublicIpInternetServices < Base
+        def href
+          _parent.href + "/internetServices"
+        end
+
+        def items
+          @items ||= []
+        end
+      end
+
+      class MockPublicIpInternetService < Base
+        def name
+          self[:name] || "Public IP Service #{object_id}"
+        end
+
+        def description
+          self[:description] || "Description for Public IP Service #{name}"
+        end
+
+        def protocol
+          self[:protocol]
+        end
+
+        def port
+          self[:port]
+        end
+
+        def enabled
+          !!self[:enabled]
+        end
+
+        def redirect_url
+          self[:redirect_url]
+        end
+
+        def timeout
+          self[:timeout] || 2
+        end
+
+        def node_collection
+          @node_collection ||= MockPublicIpInternetServiceNodes.new({}, self)
+        end
+
+        def monitor
+          nil
+        end
+      end
+
+      class MockPublicIpInternetServiceNodes < Base
+        def href
+          _parent.href + "/nodeServices"
+        end
+
+        def items
+          @items ||= [].tap do |node_array|
+            node_array.instance_variable_set("@default_port", _parent.port)
+
+            def node_array.<<(node)
+              node[:port] ||= @default_port
+              super
+            end
+          end
+        end
+      end
+
+      class MockPublicIpInternetServiceNode < Base
+        def ip_address
+          self[:ip_address]
+        end
+
+        def name
+          self[:name] || "Public IP Service Node #{object_id}"
+        end
+
+        def description
+          self[:description] || "Description for Public IP Service Node #{name}"
+        end
+
+        def port
+          self[:port]
+        end
+
+        def enabled
+          self[:enabled].to_s.downcase != "false"
+        end
+
+        def enabled=(new_value)
+          self[:enabled] = new_value
+        end
+      end
+    end
+  end
+end