fog-openstack 0.1.0

data/tests/openstack/models/compute/images_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests("Fog::Compute[:openstack] | images collection", ['openstack']) do
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      fog = Fog::Compute[:openstack]
+      test 'not nil' do
+        fog.images.all.is_a? Array
+      end
+    end
+
+  end
+end

data/tests/openstack/models/compute/security_group_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests("Fog::Compute[:openstack] | security_group", ['openstack']) do
+  tests('success') do
+    begin
+      fog = Fog::Compute[:openstack]
+
+      security_group = fog.security_groups.create(
+        :name        => 'my_group',
+        :description => 'my group'
+      )
+
+      tests('#create').succeeds do
+        security_group = fog.security_groups.create(
+          :name        => 'my_group',
+          :description => 'my group'
+        )
+
+        returns('my_group') { security_group.name }
+        returns('my group') { security_group.description }
+        returns([])         { security_group.security_group_rules }
+        returns(true, "Tenant Id is not nil")       { security_group.tenant_id != nil }
+      end
+
+      tests('#rules').succeeds do
+        tests("#create").succeeds do
+          rules_count = security_group.security_group_rules.count
+          rule        = security_group.security_group_rules.create(
+            :parent_group_id => security_group.id,
+            :ip_protocol     => 'tcp',
+            :from_port       => 1234,
+            :to_port         => 1234,
+            :ip_range        => { "cidr" => "0.0.0.0/0" }
+          )
+          returns(true, "added security group rule") { security_group.security_group_rules.count == (rules_count + 1) }
+          security_group_rule = security_group.security_group_rules.find { |r| r.id == rule.id }
+          returns(true, "security group rule has rule attributes") { security_group_rule.attributes == rule.attributes }
+        end
+
+        tests("#destroy").succeeds do
+          rule        = security_group.security_group_rules.create(
+            :parent_group_id => security_group.id,
+            :ip_protocol     => 'tcp',
+            :from_port       => 1234,
+            :to_port         => 1234,
+            :ip_range        => { "cidr" => "0.0.0.0/0" }
+          )
+          rule.destroy
+          returns(true, "successfully destroyed rule") { rule.reload == nil }
+        end
+      end
+    ensure
+      security_group.destroy if security_group
+    end
+  end
+end

data/tests/openstack/models/compute/server_tests.rb

@@ -0,0 +1,220 @@
+Shindo.tests("Fog::Compute[:openstack] | server", ['openstack']) do
+
+  tests('success') do
+
+    tests('#floating_ips').succeeds do
+      fog = Fog::Compute[:openstack]
+      net = Fog::Network[:openstack]
+      flavor = fog.flavors.first.id
+      image  = fog.images.first.id
+
+      server = fog.servers.new(:name       => 'test server',
+                               :flavor_ref => flavor,
+                               :image_ref  => image)
+      server.save
+
+      ip1 = net.floating_ips.create(:floating_network_id => 'f0000000-0000-0000-0000\
+-000000000000',
+                                                         :fixed_ip_address => '192.168.11.3')
+
+      server.associate_address(ip1.fixed_ip_address)
+      server.reload
+
+      returns( ["192.168.11.3"] ) { server.floating_ip_addresses }
+    end
+
+    tests('#security_groups').succeeds do
+      fog = Fog::Compute[:openstack]
+
+      begin
+        my_group = fog.security_groups.create(:name => 'my_group',
+                                              :description => 'my group')
+
+        flavor = fog.flavors.first.id
+        image  = fog.images.first.id
+
+        server = fog.servers.new(:name       => 'test server',
+                                 :flavor_ref => flavor,
+                                 :image_ref  => image)
+
+        server.security_groups = my_group
+
+        server.save
+
+        found_groups = server.security_groups
+        returns(1) { found_groups.length }
+
+        group = found_groups.first
+        returns('my_group') { group.name }
+        returns(server.service) { group.service }
+      ensure
+        unless Fog.mocking? then
+          server.destroy if server
+
+          begin
+            fog.servers.get(server.id).wait_for do false end
+          rescue Fog::Errors::Error
+            # ignore, server went away
+          end
+        end
+
+        my_group.destroy if my_group
+      end
+    end
+
+    tests('#failed') do
+
+      fog = Fog::Compute[:openstack]
+
+      flavor = fog.flavors.first.id
+      image  = fog.images.first.id
+
+      tests('successful server').returns(false) do
+        server = fog.servers.new( :name       => 'test server',
+                                  :flavor_ref => flavor,
+                                  :image_ref  => image,
+                                  :state      => 'success' )
+        server.failed?
+      end
+
+      tests('failed server').returns(true) do
+        server = fog.servers.new( :name       => 'test server',
+                                  :flavor_ref => flavor,
+                                  :image_ref  => image,
+                                  :state      => 'ERROR' )
+        server.failed?
+      end
+
+    end
+
+    tests('#metadata').succeeds do
+      fog = Fog::Compute[:openstack]
+
+      begin
+        flavor = fog.flavors.first.id
+        image  = fog.images.first.id
+
+        server = fog.servers.new(:name       => 'test server',
+                                 :metadata => {"foo" => "bar"},
+                                 :flavor_ref => flavor,
+                                 :image_ref  => image)
+
+        server.save
+
+        returns(1) { server.metadata.length }
+
+        server.metadata.each do |datum|
+          datum.value = 'foo'
+          datum.save
+          datum.destroy
+        end
+
+      ensure
+        unless Fog.mocking? then
+          server.destroy if server
+
+          begin
+            fog.servers.get(server.id).wait_for do false end
+          rescue Fog::Errors::Error
+            # ignore, server went away
+          end
+        end
+
+      end
+    end
+
+    tests('#resize').succeeds do
+      fog = Fog::Compute[:openstack]
+
+      begin
+        flavor = fog.flavors.first.id
+        image  = fog.images.first.id
+
+        server = fog.servers.new(:name       => 'test server',
+                                 :flavor_ref => flavor,
+                                 :image_ref  => image)
+
+        server.save
+
+        flavor_resize = fog.flavors[1].id
+        server.resize(flavor_resize)
+        server.wait_for { server.state == "VERIFY_RESIZE" } unless Fog.mocking?
+        server.revert_resize
+        server.wait_for { server.state == "ACTIVE" } unless Fog.mocking?
+        server.resize(flavor_resize)
+        server.wait_for { server.state == "VERIFY_RESIZE" } unless Fog.mocking?
+        server.confirm_resize
+
+      ensure
+        unless Fog.mocking? then
+          server.destroy if server
+
+          begin
+            fog.servers.get(server.id).wait_for do false end
+          rescue Fog::Errors::Error
+            # ignore, server went away
+          end
+        end
+      end
+    end
+
+    tests('#volumes').succeeds do
+      fog = Fog::Compute[:openstack]
+
+      begin
+        volume = fog.volumes.new(:name => 'test volume',
+                                 :description => 'test volume',
+                                 :size => 1)
+        volume.save
+        volume.wait_for { volume.status == 'available' } unless Fog.mocking?
+
+        flavor = fog.flavors.first.id
+        image  = fog.images.first.id
+
+        server = fog.servers.new(:name       => 'test server',
+                                 :flavor_ref => flavor,
+                                 :image_ref  => image)
+
+        server.save
+        server.wait_for { server.state == "ACTIVE" } unless Fog.mocking?
+
+        server.attach_volume(volume.id, '/dev/vdc')
+        volume.wait_for { volume.status == 'in-use' } unless Fog.mocking?
+
+        found_volumes = server.volumes
+        returns(1) { found_volumes.length }
+
+        volume = found_volumes.first
+        returns('test volume') { volume.name }
+
+        found_attachments = server.volume_attachments
+        returns(1) { found_attachments.length }
+
+        attachment = found_attachments.first
+        returns('/dev/vdc') { attachment['device'] }
+
+        server.detach_volume(volume.id)
+        volume.wait_for { volume.status == 'available' } unless Fog.mocking?
+
+        found_volumes = server.volumes
+        returns(0) { found_volumes.length }
+
+        found_attachments = server.volume_attachments
+        returns(0) { found_attachments.length }
+      ensure
+        unless Fog.mocking? then
+          server.destroy if server
+          volume.destroy if volume
+
+          begin
+            fog.servers.get(server.id).wait_for do false end
+            fog.volumes.get(volume.id).wait_for do false end
+          rescue Fog::Errors::Error
+            # ignore, server went away
+          end
+        end
+      end
+    end
+
+  end
+end

data/tests/openstack/models/identity/ec2_credential_tests.rb

@@ -0,0 +1,41 @@
+Shindo.tests("Fog::Identity[:openstack] | ec2_credential", ['openstack']) do
+  before do
+    openstack = Fog::Identity[:openstack]
+    tenant_id = openstack.list_tenants.body['tenants'].first['id']
+
+    @user = openstack.users.find { |user| user.name == 'foobar' }
+    @user ||= openstack.users.create({
+      :name      => 'foobar',
+      :email     => 'foo@bar.com',
+      :tenant_id => tenant_id,
+      :password  => 'spoof',
+      :enabled   => true
+    })
+
+    @ec2_credential = openstack.ec2_credentials.create({
+      :user_id   => @user.id,
+      :tenant_id => tenant_id,
+    })
+  end
+
+  after do
+    @user.ec2_credentials.each do |ec2_credential|
+      ec2_credential.destroy
+    end
+
+    @user.destroy
+  end
+
+  tests('success') do
+    tests('#destroy').returns(true) do
+      @ec2_credential.destroy
+    end
+  end
+
+  tests('failure') do
+    tests('#save').raises(Fog::Errors::Error) do
+      @ec2_credential.save
+    end
+  end
+
+end

data/tests/openstack/models/identity/ec2_credentials_tests.rb

@@ -0,0 +1,58 @@
+Shindo.tests("Fog::Identity[:openstack] | ec2_credentials", ['openstack']) do
+  before do
+    openstack = Fog::Identity[:openstack]
+    tenant_id = openstack.list_tenants.body['tenants'].first['id']
+
+    @user = openstack.users.find { |user| user.name == 'foobar' }
+    @user ||= openstack.users.create({
+      :name      => 'foobar',
+      :email     => 'foo@bar.com',
+      :tenant_id => tenant_id,
+      :password  => 'spoof',
+      :enabled   => true
+    })
+
+    @ec2_credential = openstack.ec2_credentials.create({
+      :user_id   => @user.id,
+      :tenant_id => tenant_id,
+    })
+  end
+
+  after do
+    @user.ec2_credentials.each do |ec2_credential|
+      ec2_credential.destroy
+    end
+
+    @user.destroy
+  end
+
+  tests('success') do
+    tests('#find_by_access_key').succeeds do
+      ec2_credential =
+        @user.ec2_credentials.find_by_access_key(@ec2_credential.access)
+
+      ec2_credential.access == @ec2_credential.access
+    end
+
+    tests('#create').succeeds do
+      @user.ec2_credentials.create
+    end
+
+    tests('#destroy').succeeds do
+      @user.ec2_credentials.destroy(@ec2_credential.access)
+    end
+  end
+
+  tests('fails') do
+    pending if Fog.mocking?
+
+    tests('#find_by_access_key').raises(Fog::Identity::OpenStack::NotFound) do
+      @user.ec2_credentials.find_by_access_key('fake')
+    end
+
+    tests('#destroy').raises(Fog::Identity::OpenStack::NotFound) do
+      @user.ec2_credentials.destroy('fake')
+    end
+  end
+
+end

data/tests/openstack/models/identity/role_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests("Fog::Identity[:openstack] | role", ['openstack']) do
+  @instance = Fog::Identity[:openstack].roles.new({:name => 'Role Name', :user_id => 1, :role_id => 1})
+  @tenant   = Fog::Identity[:openstack].tenants.create(:name => 'test_user')
+  @user     = Fog::Identity[:openstack].users.create(:name => 'test_user', :tenant_id => @tenant.id, :password => 'spoof')
+
+  tests('success') do
+    tests('#save').returns(true) do
+      @instance.save
+    end
+
+    tests('#add_to_user(@user.id, @tenant.id)').returns(true) do
+      @instance.add_to_user(@user.id, @tenant.id)
+    end
+
+    tests('#remove_to_user(@user.id, @tenant.id)').returns(true) do
+      @instance.remove_to_user(@user.id, @tenant.id)
+    end
+
+    tests('#destroy').returns(true) do
+      @instance.destroy
+    end
+  end
+
+  @user.destroy
+  @tenant.destroy
+end

data/tests/openstack/models/identity/roles_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests("Fog::Identity[:openstack] | roles", ['openstack']) do
+  @tenant   = Fog::Identity[:openstack].tenants.create(:name => 'test_user')
+  @user     = Fog::Identity[:openstack].users.create(:name => 'test_user', :tenant_id => @tenant.id, :password => 'spoof')
+  @role     = Fog::Identity[:openstack].roles(:user => @user, :tenant => @tenant).create(:name => 'test_role')
+  @roles    = Fog::Identity[:openstack].roles(:user => @user, :tenant => @tenant)
+
+  tests('success') do
+    tests('#all').succeeds do
+      @roles.all
+    end
+
+    tests('#get').succeeds do
+      @roles.get @roles.first.id
+    end
+  end
+
+  @role.destroy
+  @user.destroy
+  @tenant.destroy
+end

data/tests/openstack/models/identity/tenant_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests("Fog::Identity[:openstack] | tenant", ['openstack']) do
+  tests('success') do
+    tests('#roles_for(0)').succeeds do
+      instance = Fog::Identity[:openstack].tenants.first
+      instance.roles_for(0)
+    end
+
+    tests('#users').succeeds do
+      instance = Fog::Identity[:openstack].tenants.first
+
+      instance.users.count != Fog::Identity[:openstack].users.count
+    end
+  end
+
+  tests('CRUD') do
+    tests('#create').succeeds do
+      @instance = Fog::Identity[:openstack].tenants.create(:name => 'test')
+      !@instance.id.nil?
+    end
+
+    tests('#update').succeeds do
+      @instance.update(:name => 'test2')
+      @instance.name == 'test2'
+    end
+
+    tests('#destroy').succeeds do
+      @instance.destroy == true
+    end
+  end
+end