fog-aws 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6fadd0502aac63d36fb75307b3f73c318aa7b761
-  data.tar.gz: 91359d42a5922d20b668da81fc7073bf0534a5ba
+  metadata.gz: 2c3c13ca1176a433f26e6e0015841bff3ee5d2e5
+  data.tar.gz: b291f9e3e4b7fe39ead2f0ed2c861d9baa1a438f
 SHA512:
-  metadata.gz: 14e6301495abbdfeaf6f03a007495a4cbab38dedfd44bcea3871b97b5a284e0fd7503082cab5c495c54f8bf963b03157b0238a8c1541d77889bf4e9501589cef
-  data.tar.gz: 75d9dfc7a737ea2656f54fce0c2a49abf95f7daa6f6c45e07bc81e3ec95e479945273a55dd81706ebef896ec8579dafd05047bc7ee97532ab8308047e59bde61
+  metadata.gz: 7e6b50d6cd48a874d5d2c2e283589b3e0530e512a32764af8bb52f9a7188873a8c1a5e234b3e02b05089077cb7214cf50147344b72cc5d756f456a355cf70750
+  data.tar.gz: a802d95bb0b4e2b118bf8aca81babccc07a0dd2a6b8f7b993a314ba6c8693731ad72514fcd383cb5a8426f16b82f7173b8436ac30854cb42cd6a7a2b549f1f42

data/lib/fog/aws/iam.rb

@@ -85,14 +85,16 @@ module Fog
       request :upload_signing_certificate
 
       model_path 'fog/aws/models/iam'
-      model       :user
-      collection  :users
-      model       :policy
-      collection  :policies
       model       :access_key
       collection  :access_keys
+      model       :group
+      collection  :groups
+      model       :policy
+      collection  :policies
       model       :role
       collection  :roles
+      model       :user
+      collection  :users
 
       class Mock
         def self.data
@@ -182,6 +184,11 @@ module Fog
         end
 
         def current_user
+          unless self.data[:users].key?("root")
+            root = self.data[:users]["root"] # sets the hash
+            root[:arn].gsub!("user/", "")    # root user doesn't have "user/" key prefix
+          end
+
           self.data[:users]["root"]
         end
       end

data/lib/fog/aws/models/iam/group.rb

@@ -0,0 +1,78 @@
+module Fog
+  module AWS
+    class IAM
+      class Group < Fog::Model
+
+        identity :id, :aliases => 'GroupId'
+
+        attribute :arn,   :aliases => 'Arn'
+        attribute :name,  :aliases => 'GroupName'
+        attribute :path,  :aliases => 'Path'
+        attribute :users, :aliases => 'Users', :type => :array
+
+        def add_user(user_or_name)
+          requires :name
+
+          user = if user_or_name.is_a?(Fog::AWS::IAM::User)
+                   user_or_name
+                 else
+                   service.users.new(:id => user_or_name)
+                 end
+
+          service.add_user_to_group(self.name, user.identity)
+          merge_attributes(:users => self.users + [user])
+        end
+
+        def attach(policy_arn)
+          requires :name
+
+          service.attach_group_policy(self.name, policy_arn)
+        end
+
+        def save
+          if !persisted?
+            requires :name
+
+            merge_attributes(
+              service.create_group(self.name, self.path).body["Group"]
+            )
+          else
+            params = {}
+
+            if self.name
+              params['NewGroupName'] = self.name
+            end
+
+            if self.path
+              params['NewPath'] = self.path
+            end
+
+            service.update_group(self.name, params)
+            true
+          end
+        end
+
+        def policies
+          requires :name
+
+          service.policies(:group_name => self.name)
+        end
+
+        def reload
+          requires :name
+
+          data = begin
+                   collection.get(self.name)
+                 rescue Excon::Errors::SocketError
+                   nil
+                 end
+
+          return unless data
+
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/iam/groups.rb

@@ -0,0 +1,59 @@
+require 'fog/aws/models/iam/group'
+
+module Fog
+  module AWS
+    class IAM
+      class Groups < Fog::Collection
+
+        attribute :truncated, :aliases => 'IsTruncated', :type => :boolean
+        attribute :marker,    :aliases => 'Marker'
+        attribute :username
+
+        model Fog::AWS::IAM::Group
+
+        def all(options = {})
+          merge_attributes(options)
+
+          data, records = if self.username
+                            response = service.list_groups_for_user(self.username, options)
+                            [response.body, response.body['GroupsForUser']]
+                          else
+                            response = service.list_groups(options)
+                            [response.body, response.body['Groups']]
+                          end
+
+          merge_attributes(data)
+          load(records)
+        end
+
+        def get(identity)
+          data = service.get_group(identity)
+
+          group = data.body['Group']
+          users = data.body['Users'].map { |u| service.users.new(u) }
+
+          new(group.merge(:users => users))
+        rescue Fog::AWS::IAM::NotFound
+          nil
+        end
+
+        def each
+          if !block_given?
+            self
+          else
+            subset = dup.all
+
+            subset.each { |f| yield f }
+
+            while subset.truncated
+              subset = subset.all('Marker' => subset.marker, 'MaxItems' => 1000)
+              subset.each { |f| yield f }
+            end
+
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/iam/policies.rb

@@ -7,29 +7,57 @@ module Fog
         model Fog::AWS::IAM::Policy
 
         attribute :username
+        attribute :group_name
 
         def all
-          requires :username
-          # AWS method get_user_policy only returns an array of policy names, this is kind of useless,
-          # that's why it has to loop through the list to get the details of each element. I don't like it because it makes this method slow
-          policy_names = service.list_user_policies(self.username).body['PolicyNames'] # it returns an array
-          policies = policy_names.map do |policy_name|
-            service.get_user_policy(policy_name, self.username).body['Policy']
-          end
+          requires_one :username, :group_name
+
+          policies = if self.username
+                       all_by_user(self.username)
+                     else
+                       all_by_group(self.group_name)
+                     end
+
           load(policies) # data is an array of attribute hashes
         end
 
         def get(identity)
-          requires :username
+          requires_one :username, :group_name
+
+          data = if self.username
+                   service.get_user_policy(identity, self.username)
+                 else
+                   service.get_group_policy(identity, self.group_name)
+                 end.body['Policy']
 
-          data = service.get_user_policy(identity, self.username).body['Policy']
-          new(data) # data is an attribute hash
+          new(data)
         rescue Fog::AWS::IAM::NotFound
           nil
         end
 
         def new(attributes = {})
-          super({ :username => self.username }.merge!(attributes))
+          super(self.attributes.merge(attributes))
+        end
+
+        private
+
+        # AWS method get_user_policy and list_group_policies only returns an array of policy names, this is kind of useless,
+        # that's why it has to loop through the list to get the details of each element. I don't like it because it makes this method slow
+
+        def all_by_group(group_name)
+          response = service.list_group_policies(group_name)
+
+          response.body['PolicyNames'].map do |policy_name|
+            service.get_group_policy(policy_name, group_name).body['Policy']
+          end
+        end
+
+        def all_by_user(username)
+          response = service.list_user_policies(username)
+
+          response.body['PolicyNames'].map do |policy_name|
+            service.get_user_policy(policy_name, username).body['Policy']
+          end
         end
       end
     end

data/lib/fog/aws/models/iam/policy.rb

@@ -6,12 +6,19 @@ module Fog
         attribute :username, :aliases => 'UserName'
         attribute :document, :aliases => 'PolicyDocument'
 
+        attr_accessor :group_name
+
         def save
           requires :id
-          requires :username
+          requires_one :username, :group_name
           requires :document
 
-          data = service.put_user_policy(username, id, document).body
+          data = if username
+                   service.put_user_policy(username, id, document).body
+                 else
+                   service.put_group_policy(group_name, id, document).body
+                 end
+
           merge_attributes(data)
           true
         end

data/lib/fog/aws/models/iam/user.rb

@@ -3,32 +3,62 @@ module Fog
     class IAM
       class User < Fog::Model
         identity  :id, :aliases => 'UserName'
-        attribute :path, :aliases => 'Path'
-        attribute :arn, :aliases => 'Arn'
-        attribute :user_id, :aliases => 'UserId'
+
+        attribute :path,       :aliases => 'Path'
+        attribute :arn,        :aliases => 'Arn'
+        attribute :user_id,    :aliases => 'UserId'
         attribute :created_at, :aliases => 'CreateDate', :type => :time
 
-        def save
+        def access_keys
           requires :id
-          data = service.create_user(id, path || '/').body['User']
-          merge_attributes(data)
-          true
+
+          service.access_keys(:username => id)
         end
 
         def destroy
           requires :id
+
           service.delete_user(id)
           true
         end
 
+        def groups
+          service.groups(:username => self.identity)
+        end
+
         def policies
           requires :id
+
           service.policies(:username => id)
         end
 
-        def access_keys
+        def password=(password)
+          requires :identity
+
+          has_password = !!self.password_created_at
+
+          if has_password && password.nil?
+            service.delete_login_profile(self.identity)
+          elsif has_password
+            service.update_login_profile(self.identity, password)
+          elsif !password.nil?
+            service.create_login_profile(self.identity, password)
+          end
+        end
+
+        def password_created_at
+          requires :identity
+
+          service.get_login_profile(self.identity).body["LoginProfile"]["CreateDate"]
+        rescue Fog::AWS::IAM::NotFound
+          nil
+        end
+
+        def save
           requires :id
-          service.access_keys(:username => id)
+          data = service.create_user(id, path || '/').body['User']
+          merge_attributes(data)
+          true
         end
       end
     end

data/lib/fog/aws/parsers/iam/list_managed_policies.rb

@@ -1,8 +1,9 @@
+require 'fog/aws/parsers/iam/policy_parser'
+
 module Fog
   module Parsers
     module AWS
       module IAM
-        require 'fog/aws/parsers/iam/policy_parser'
         class ListManagedPolicies < Fog::Parsers::AWS::IAM::PolicyParser
           def reset
             super

data/lib/fog/aws/parsers/iam/policy_parser.rb

@@ -13,10 +13,10 @@ module Fog
             when 'Policies'
               @stack << name
             when 'Policy'
-              @role =fresh_policy
+              @policy = fresh_policy
             when 'member'
               if @stack.last == 'Policies'
-                @role = fresh_policy
+                @policy = fresh_policy
               end
             end
             super

data/lib/fog/aws/requests/iam/add_user_to_group.rb

@@ -30,22 +30,21 @@ module Fog
 
       class Mock
         def add_user_to_group(group_name, user_name)
-          if data[:groups].key? group_name
-            if data[:users].key? user_name
+          unless data[:groups].key?(group_name)
+            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          end
+
+          unless data[:users].key?(user_name)
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
 
-              unless data[:groups][group_name][:members].include?(user_name)
-                data[:groups][group_name][:members] << user_name
-              end
+          unless data[:groups][group_name][:members].include?(user_name)
+            data[:groups][group_name][:members] << user_name
+          end
 
-              Excon::Response.new.tap do |response|
-                response.status = 200
-                response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
-              end
-            else
-              raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
-            end
-          else
-            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
           end
         end
       end

data/lib/fog/aws/requests/iam/attach_group_policy.rb

@@ -20,10 +20,10 @@ module Fog
         #
         def attach_group_policy(group_name, policy_arn)
           request(
-            'Action'          => 'AttachGroupPolicy',
-            'GroupName'       => group_name,
-            'PolicyArn'      => policy_arn,
-            :parser           => Fog::Parsers::AWS::IAM::Basic.new
+            'Action'    => 'AttachGroupPolicy',
+            'GroupName' => group_name,
+            'PolicyArn' => policy_arn,
+            :parser     => Fog::Parsers::AWS::IAM::Basic.new
           )
         end
       end

data/lib/fog/aws/requests/iam/create_login_profile.rb

@@ -29,6 +29,40 @@ module Fog
           })
         end
       end
+
+      class Mock
+        def create_login_profile(user_name, password)
+          unless self.data[:users].key?(user_name)
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+
+          user = self.data[:users][user_name]
+
+          if user[:login_profile]
+            raise Fog::AWS::IAM::EntityAlreadyExists, "Login Profile for user #{user_name} already exists."
+          end
+
+          created_at = Time.now
+
+          user[:login_profile] = {
+            :created_at => created_at,
+            :password   => password,
+          }
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "LoginProfile" => {
+              "UserName"   => user_name,
+              "CreateDate" => created_at
+            },
+            "RequestId" => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/delete_login_profile.rb

@@ -24,6 +24,31 @@ module Fog
           })
         end
       end
+
+      class Mock
+        def delete_login_profile(user_name)
+          unless self.data[:users].key?(user_name)
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+
+          user = self.data[:users][user_name]
+
+          unless user[:login_profile]
+            raise Fog::AWS::IAM::NotFound, "Cannot find Login Profile for User #{user_name}"
+          end
+
+          user.delete(:login_profile)
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "RequestId" => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/get_group.rb

@@ -45,9 +45,9 @@ module Fog
           Excon::Response.new.tap do |response|
             response.body = { 'Group' =>  {
                                              'GroupId'   => data[:groups][group_name][:group_id],
-                                             'Path'     => data[:groups][group_name][:path],
+                                             'Path'      => data[:groups][group_name][:path],
                                              'GroupName' => group_name,
-                                             'Arn'      => (data[:groups][group_name][:arn]).strip
+                                             'Arn'       => (data[:groups][group_name][:arn]).strip
                                           },
                               'Users' => data[:groups][group_name][:members].map { |user| get_user(user).body['User'] },
                               'RequestId'   => Fog::AWS::Mock.request_id }

data/lib/fog/aws/requests/iam/get_group_policy.rb

@@ -22,10 +22,10 @@ module Fog
         #
         def get_group_policy(policy_name, group_name)
           request({
-            'Action'      => 'GetGroupPolicy',
-            'PolicyName'  => policy_name,
-            'GroupName'    => group_name,
-            :parser       => Fog::Parsers::AWS::IAM::GetGroupPolicy.new
+            'Action'     => 'GetGroupPolicy',
+            'PolicyName' => policy_name,
+            'GroupName'  => group_name,
+            :parser      => Fog::Parsers::AWS::IAM::GetGroupPolicy.new
           })
         end
       end

data/lib/fog/aws/requests/iam/get_login_profile.rb

@@ -28,6 +28,33 @@ module Fog
           })
         end
       end
+
+      class Mock
+        def get_login_profile(user_name)
+          unless self.data[:users].key?(user_name)
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+
+          profile = self.data[:users][user_name][:login_profile]
+
+          unless profile
+            raise Fog::AWS::IAM::NotFound, "Cannot find Login Profile for User #{user_name}"
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "LoginProfile" => {
+              "UserName"   => user_name,
+              "CreateDate" => profile[:created_at]
+            },
+            "RequestId" => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/list_group_policies.rb

@@ -32,6 +32,22 @@ module Fog
           }.merge!(options))
         end
       end
+
+      class Mock
+        def list_group_policies(group_name, options = {})
+          #FIXME: doesn't use options atm
+          if data[:groups].key? group_name
+            Excon::Response.new.tap do |response|
+              response.body = { 'PolicyNames' => data[:groups][group_name][:policies].keys,
+                                'IsTruncated' => false,
+                                'RequestId'   => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/update_group.rb

@@ -26,12 +26,49 @@ module Fog
         #
         def update_group(group_name, options = {})
           request({
-            'Action'      => 'UpdateGroup',
-            'GroupName'    => group_name,
-            :parser       => Fog::Parsers::AWS::IAM::UpdateGroup.new
+            'Action'    => 'UpdateGroup',
+            'GroupName' => group_name,
+            :parser     => Fog::Parsers::AWS::IAM::UpdateGroup.new
           }.merge!(options))
         end
       end
+
+      class Mock
+        def update_group(group_name, options = {})
+          raise Fog::AWS::IAM::NotFound.new(
+            "The user with name #{group_name} cannot be found."
+          ) unless self.data[:groups].key?(group_name)
+
+          response = Excon::Response.new
+
+          group = self.data[:groups][group_name]
+
+          new_path       = options['NewPath']
+          new_group_name = options['NewGroupName']
+
+          if new_path
+            unless new_path.match(/\A\/[a-zA-Z0-9]+\/\Z/)
+              raise Fog::AWS::IAM::ValidationError,
+                "The specified value for path is invalid. It must begin and end with / and contain only alphanumeric characters and/or / characters."
+            end
+
+            group[:path] = new_path
+          end
+
+          if new_group_name
+            self.data[:groups].delete(group_name)
+            self.data[:groups][new_group_name] = group
+          end
+
+          response.status = 200
+          response.body = {
+            'Group'     => {},
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/update_login_profile.rb

@@ -26,6 +26,31 @@ module Fog
           })
         end
       end
+
+      class Mock
+        def update_login_profile(user_name, password)
+          unless self.data[:users].key?(user_name)
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+
+          user = self.data[:users][user_name]
+
+          unless user[:login_profile]
+            raise Fog::AWS::IAM::NotFound, "Cannot find Login Profile for User #{user_name}"
+          end
+
+          user[:login_profile][:password] = password
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "RequestId" => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module AWS
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

data/tests/models/iam/groups_tests.rb

@@ -0,0 +1,59 @@
+Shindo.tests("Fog::Compute[:iam] | groups", ['aws','iam']) do
+
+  service     = Fog::AWS[:iam]
+  group_name  = uniq_id('fog-test-group')
+  policy_name = uniq_id('fog-test-policy')
+  group       = nil
+  document    = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+  tests('#create').succeeds do
+    group = service.groups.create(:name => group_name)
+
+    group.name == group_name
+  end
+
+  tests('#all').succeeds do
+    service.groups.all.map(&:name).include?(group_name)
+  end
+
+  tests('update').succeeds do
+    new_path = group.path = "/newpath/"
+    group.save
+
+    group.reload.path == new_path
+  end
+
+  tests('group') do
+    policy = nil
+
+    tests('#policies', '#create') do
+      policy = group.policies.create(:id => policy_name, :document => document)
+    end
+
+    tests('#policies', '#get').succeeds do
+      group.policies.get(policy_name) != nil
+    end
+
+    tests('#policies', '#all').succeeds do
+      group.policies.all.map(&:id).include?(policy.id)
+    end
+
+    tests('#users', 'when none').succeeds do
+      group.users.empty?
+    end
+
+    user = nil
+
+    tests('#add_user').succeeds do
+      user = service.users.create(:id => 'fog-test')
+
+      group.add_user(user)
+
+      group.users.include?(user)
+    end
+
+    tests('#users').succeeds do
+      group.reload.users.map(&:identity).include?(user.identity)
+    end
+  end
+end

data/tests/models/iam/users_tests.rb

@@ -1,20 +1,20 @@
 Shindo.tests("Fog::Compute[:iam] | users", ['aws','iam']) do
 
-  @iam = Fog::AWS[:iam]
-  @user_one_name = 'fake_user_one'
-  @user_two_name = 'fake_user_two'
+  iam = Fog::AWS[:iam]
 
-  @user_three_name = 'fake_user_three'
-  @user_three_path = '/path/to/fake_user_three/'
-  @user_four_name = 'fake_user_four'
+  user_one_name   = 'fake_user_one'
+  user_two_name   = 'fake_user_two'
+  user_three_name = 'fake_user_three'
+  user_three_path = '/path/to/fake_user_three/'
+  user_four_name  = 'fake_user_four'
 
   def all_users
-    @iam.users.all.select{|user| user.id =~ /^fake_user/ }
+    Fog::AWS[:iam].users.all.select{|user| user.id =~ /^fake_user/ }
   end
 
   tests('#create').succeeds do
-    @user_one = @iam.users.create(:id => @user_one_name)
-    @user_one.id == @user_one_name
+    user_one = iam.users.create(:id => user_one_name)
+    user_one.id == user_one_name
   end
 
   tests('#all','there is only one user').succeeds do
@@ -22,54 +22,78 @@ Shindo.tests("Fog::Compute[:iam] | users", ['aws','iam']) do
   end
 
   tests('#all','the only user should match').succeeds do
-    all_users.first.id == @user_one_name
+    all_users.first.id == user_one_name
   end
 
   tests('#create','a second user').succeeds do
-    @user_two = @iam.users.create(:id => @user_two_name)
-    @user_two.id == @user_two_name
+    user_two = iam.users.create(:id => user_two_name)
+    user_two.id == user_two_name
   end
 
   tests('#all','there are two users').succeeds do
     all_users.size == 2
   end
 
+  user = iam.users.get(user_one_name)
+
   tests('#get','an existing user').succeeds do
-    @iam.users.get(@user_one_name).id == @user_one_name
+    user.id == user_one_name
   end
 
   tests('#current').succeeds do
-    @iam.users.current
+    iam.users.current
   end
 
   tests('#get',"returns nil if the user doesn't exists").succeeds do
-    @iam.users.get('non-exists') == nil
+    iam.users.get('non-exists') == nil
   end
 
   tests('#policies','it has no policies').succeeds do
-    @iam.users.get(@user_one_name).policies.empty?
+    user.policies.empty?
   end
 
   tests('#access_keys','it has no keys').succeeds do
-    @iam.users.get(@user_one_name).access_keys.empty?
+    user.access_keys.empty?
+  end
+
+  tests('#password=nil', 'without a password').succeeds do
+    user.password = nil
+    user.password_created_at.nil?
+  end
+
+  tests('#password=(password)').succeeds do
+    user.password = SecureRandom.base64(10)
+
+    user.password_created_at.is_a?(Time)
+  end
+
+  tests('#password=(update_password)').succeeds do
+    user.password = SecureRandom.base64(10)
+
+    user.password_created_at.is_a?(Time)
+  end
+
+  tests('#password=nil', 'with a password').succeeds do
+    user.password = nil
+    user.password_created_at.nil?
   end
 
   tests('#create', 'assigns path').succeeds do
-    @user_three = @iam.users.create(:id => @user_three_name, :path => @user_three_path)
-    @user_three.path == @user_three_path
+    user_three = iam.users.create(:id => user_three_name, :path => user_three_path)
+    user_three.path == user_three_path
   end
 
   tests('#create', 'defaults path to /').succeeds do
-    @user_four = @iam.users.create(:id => @user_four_name)
-    @user_four.path == '/'
+    user_four = iam.users.create(:id => user_four_name)
+    user_four.path == '/'
   end
 
   tests('#destroy','an existing user').succeeds do
-    @iam.users.get(@user_one_name).destroy
+    iam.users.get(user_one_name).destroy
   end
 
   tests('#destroy','clean up remaining user').succeeds do
-    @iam.users.get(@user_two_name).destroy
+    iam.users.get(user_two_name).destroy
   end
 
 end

data/tests/requests/compute/instance_attrib_tests.rb

@@ -45,7 +45,7 @@ Shindo.tests('Fog::Compute[:aws] | describe_instance_attribute request', ['aws']
     # Setting up the environment
     @instance_id = nil
     @ami = 'ami-79c0ae10'
-    key_name = 'fog-test-key'
+    key_name = uniq_id('fog-test-key')
     @key = Fog::Compute[:aws].key_pairs.create(:name => key_name)
     instance_type = "t1.micro"
     @az = "us-east-1a"

data/tests/requests/compute/instance_tests.rb

@@ -172,7 +172,7 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
     end
 
     # Create a keypair for decrypting the password
-    key_name = 'fog-test-key'
+    key_name = uniq_id('fog-test-key')
     key = Fog::Compute[:aws].key_pairs.create(:name => key_name)
 
     tests("#run_instances").formats(@run_instances_format) do

data/tests/requests/compute/route_tests.rb

@@ -49,7 +49,7 @@ Shindo.tests('Fog::Compute[:aws] | route table requests', ['aws']) do
   @internet_gateway_id = Fog::Compute[:aws].create_internet_gateway.body['internetGatewaySet'].first['internetGatewayId']
   @alt_internet_gateway_id = Fog::Compute[:aws].create_internet_gateway.body['internetGatewaySet'].first['internetGatewayId']
   @network_interface_id = @network_interface['networkInterface']['networkInterfaceId']
-  key_name = 'fog-test-key'
+  key_name = uniq_id('fog-test-key')
   key = Fog::Compute[:aws].key_pairs.create(:name => key_name)
   @cidr_block = '10.0.10.0/24'
   @destination_cidr_block = '10.0.10.0/23'
@@ -83,7 +83,7 @@ Shindo.tests('Fog::Compute[:aws] | route table requests', ['aws']) do
       Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id, nil).body
     end
 
-    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => key_name, :subnet_id => @subnet_id)
     instance.wait_for { state.eql? "running" }
     tests("#create_route('#{@route_table_id}', '10.0.10.0/22', 'nil', '#{instance.id}')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/22', nil, instance.id).body
@@ -103,7 +103,7 @@ Shindo.tests('Fog::Compute[:aws] | route table requests', ['aws']) do
       Fog::Compute[:aws].replace_route(@route_table_id, @destination_cidr_block, {'gatewayId' => @alt_internet_gateway_id}).body
     end
 
-    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => key_name, :subnet_id => @subnet_id)
     instance.wait_for { state.eql? "running" }
     tests("#replace_route('#{@route_table_id}', '10.0.10.0/22', {'instanceId' => '#{instance.id}'})").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].replace_route(@route_table_id, '10.0.10.0/22', {'instanceId' => instance.id}).body
@@ -162,7 +162,7 @@ Shindo.tests('Fog::Compute[:aws] | route table requests', ['aws']) do
     @route_table_id = Fog::Compute[:aws].create_route_table(vpc.id).body['routeTable'].first['routeTableId']
     @association_id = Fog::Compute[:aws].associate_route_table(@route_table_id, @subnet_id).body['associationId']
     Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id, nil)
-    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => key_name, :subnet_id => @subnet_id)
     instance.wait_for { state.eql? "running" }
 
     # Tests create_route_table

data/tests/requests/iam/user_tests.rb

@@ -1,50 +1,78 @@
 Shindo.tests('AWS::IAM | user requests', ['aws']) do
+  service = Fog::AWS[:iam]
 
   begin
-    Fog::AWS[:iam].delete_group('fog_user_tests')
+    service.delete_group('fog_user_tests')
   rescue Fog::AWS::IAM::NotFound
   end
 
   begin
-    Fog::AWS[:iam].delete_user('fog_user').body
+    service.delete_user('fog_user').body
   rescue Fog::AWS::IAM::NotFound
   end
 
-  Fog::AWS[:iam].create_group('fog_user_tests')
+  username = 'fog_user'
 
+  service.create_group('fog_user_tests')
 
-  tests("#create_user('fog_user')").data_matches_schema(AWS::IAM::Formats::CREATE_USER) do
-    Fog::AWS[:iam].create_user('fog_user').body
+  tests("#create_user('#{username}')").data_matches_schema(AWS::IAM::Formats::CREATE_USER) do
+    service.create_user(username).body
   end
 
   tests("#list_users").data_matches_schema(AWS::IAM::Formats::LIST_USER) do
-    Fog::AWS[:iam].list_users.body
+    service.list_users.body
   end
 
-  tests("#get_user('fog_user')").data_matches_schema(AWS::IAM::Formats::GET_USER) do
-    Fog::AWS[:iam].get_user('fog_user').body
+  tests("#get_user('#{username}')").data_matches_schema(AWS::IAM::Formats::GET_USER) do
+    service.get_user(username).body
   end
 
   tests("#get_user").data_matches_schema(AWS::IAM::Formats::GET_CURRENT_USER) do
-    Fog::AWS[:iam].get_user.body
+    body = Fog::AWS[:iam].get_user.body
+    if Fog.mocking?
+      tests("correct root arn").returns(true) {
+        body["User"]["Arn"].end_with?(":root")
+      }
+    end
+
+    body
+  end
+
+  tests("#create_login_profile") do
+    service.create_login_profile(username, SecureRandom.base64(10))
+  end
+
+  tests("#get_login_profile") do
+    service.get_login_profile(username)
+  end
+
+  tests("#update_login_profile") do
+    # avoids Fog::AWS::IAM::Error: EntityTemporarilyUnmodifiable => Login Profile for User instance cannot be modified while login profile is being created.
+    if Fog.mocking?
+      service.update_login_profile(username, SecureRandom.base64(10))
+    end
+  end
+
+  tests("#delete_login_profile") do
+    service.delete_login_profile(username)
   end
 
-  tests("#add_user_to_group('fog_user_tests', 'fog_user')").data_matches_schema(AWS::IAM::Formats::BASIC) do
-    Fog::AWS[:iam].add_user_to_group('fog_user_tests', 'fog_user').body
+  tests("#add_user_to_group('fog_user_tests', '#{username}')").data_matches_schema(AWS::IAM::Formats::BASIC) do
+    service.add_user_to_group('fog_user_tests', username).body
   end
 
-  tests("#list_groups_for_user('fog_user')").data_matches_schema(AWS::IAM::Formats::GROUPS) do
-    Fog::AWS[:iam].list_groups_for_user('fog_user').body
+  tests("#list_groups_for_user('#{username}')").data_matches_schema(AWS::IAM::Formats::GROUPS) do
+    service.list_groups_for_user(username).body
   end
 
-  tests("#remove_user_from_group('fog_user_tests', 'fog_user')").data_matches_schema(AWS::IAM::Formats::BASIC) do
-    Fog::AWS[:iam].remove_user_from_group('fog_user_tests', 'fog_user').body
+  tests("#remove_user_from_group('fog_user_tests', '#{username}')").data_matches_schema(AWS::IAM::Formats::BASIC) do
+    service.remove_user_from_group('fog_user_tests', username).body
   end
 
-  tests("#delete_user('fog_user')").data_matches_schema(AWS::IAM::Formats::BASIC) do
-    Fog::AWS[:iam].delete_user('fog_user').body
+  tests("#delete_user('#{username}')").data_matches_schema(AWS::IAM::Formats::BASIC) do
+    service.delete_user(username).body
   end
 
-  Fog::AWS[:iam].delete_group('fog_user_tests')
+  service.delete_group('fog_user_tests')
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fog-aws
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Josh Lane
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -253,6 +253,8 @@ files:
 - lib/fog/aws/models/glacier/vaults.rb
 - lib/fog/aws/models/iam/access_key.rb
 - lib/fog/aws/models/iam/access_keys.rb
+- lib/fog/aws/models/iam/group.rb
+- lib/fog/aws/models/iam/groups.rb
 - lib/fog/aws/models/iam/policies.rb
 - lib/fog/aws/models/iam/policy.rb
 - lib/fog/aws/models/iam/role.rb
@@ -1290,6 +1292,7 @@ files:
 - tests/models/elb/tagging_tests.rb
 - tests/models/glacier/model_tests.rb
 - tests/models/iam/access_keys_tests.rb
+- tests/models/iam/groups_tests.rb
 - tests/models/iam/policies_tests.rb
 - tests/models/iam/roles_tests.rb
 - tests/models/iam/users_tests.rb