samanage 1.9.33 → 2.0.03

data/spec/api/samanage_mobile_spec.rb

@@ -1,84 +1,80 @@
 require 'samanage'
 
 describe Samanage::Api do
-	context 'Mobile' do
-		describe 'API Functions' do
-			before(:all) do
-				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@samanage = Samanage::Api.new(token: TOKEN)
-				@mobiles = @samanage.mobiles
-			end
-			it 'get_mobiles: it returns API call of mobiles' do
-				api_call = @samanage.get_mobiles
-				expect(api_call).to be_a(Hash)
-				expect(api_call[:total_count]).to be_an(Integer)
-				expect(api_call).to have_key(:response)
-				expect(api_call).to have_key(:code)
-			end
-			it 'collect_mobiles: collects array of mobiles' do
-				mobile_count = @samanage.get_mobiles[:total_count]
-				expect(@mobiles).to be_an(Array)
-				expect(@mobiles.size).to eq(mobile_count)
-			end
-			it 'create_mobile(payload: json): creates a mobile' do
-				mobile_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				serial_number = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
-				json = {
-					:mobile => {
-						model: 'test',
-						manufacturer: mobile_name,
-						serial_number:  serial_number,
-					}
-				}
-				mobile_create = @samanage.create_mobile(payload: json)
+  context 'Mobile' do
+    describe 'API Functions' do
+      before(:all) do
+        TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @mobiles = @samanage.mobiles
+      end
+      it 'get_mobiles: it returns API call of mobiles' do
+        api_call = @samanage.get_mobiles
+        expect(api_call).to be_a(Hash)
+        expect(api_call[:total_count]).to be_an(Integer)
+        expect(api_call).to have_key(:response)
+        expect(api_call).to have_key(:code)
+      end
+      it 'collect_mobiles: collects array of mobiles' do
+        mobile_count = @samanage.get_mobiles[:total_count]
+        expect(@mobiles).to be_an(Array)
+        expect(@mobiles.size).to eq(mobile_count)
+      end
+      it 'create_mobile(payload: json): creates a mobile' do
+        mobile_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        serial_number = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+        json = {
+          :mobile => {
+            model: 'test',
+            manufacturer: mobile_name,
+            serial_number:  serial_number,
+          }
+        }
+        mobile_create = @samanage.create_mobile(payload: json)
 
-				expect(mobile_create[:data]['id']).to be_an(Integer)
-				expect(mobile_create[:data]['manufacturer']).to eq(mobile_name)
-			end
-			it 'create_mobile: fails if no serial' do
-				mobile_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				json = {
-					:mobile => {
-						model: 'test',
-						manufacturer: mobile_name,
-					}
-				}
-				expect{@samanage.create_mobile(payload: json)}.to raise_error(Samanage::InvalidRequest)
-			end
-			it 'find_mobile: returns a mobile card by known id' do
-				sample_id = @mobiles.sample['id']
-				mobile = @samanage.find_mobile(id: sample_id)
+        expect(mobile_create[:data]['id']).to be_an(Integer)
+        expect(mobile_create[:data]['manufacturer']).to eq(mobile_name)
+      end
+      it 'create_mobile: fails if no serial' do
+        mobile_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        json = {
+          :mobile => {
+            model: 'test',
+            manufacturer: mobile_name,
+          }
+        }
+        expect{@samanage.create_mobile(payload: json)}.to raise_error(Samanage::InvalidRequest)
+      end
+      it 'find_mobile: returns a mobile card by known id' do
+        sample_id = @mobiles.sample['id']
+        mobile = @samanage.find_mobile(id: sample_id)
 
-				expect(mobile[:data]['id']).to eq(sample_id)  # id should match found mobile
-				expect(mobile[:data]).to have_key('manufacturer')
-				expect(mobile[:data]).to have_key('serial_number')
-				expect(mobile[:data]).to have_key('id')
-			end
-			it 'find_mobile: returns nothing for an invalid id' do
-				sample_id = (0..10).entries.sample
-				expect{@samanage.find_mobile(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found mobile
-			end
-			it 'update_mobile: update_mobile by id' do
-				sample_id = @mobiles.sample['id']
-				new_name = (0...50).map {('a'..'z').to_a[rand(26)] }.join
-				json = {
-					:mobile => {
-						:manufacturer => new_name
-					}
-				}
-				mobile_update = @samanage.update_mobile(payload: json, id: sample_id)
-				expect(mobile_update[:data]["manufacturer"]).to eq(new_name)
-				expect(mobile_update[:code]).to eq(200).or(201)
-			end
-			it 'deletes a valid mobile' do
+        expect(mobile[:data]['id']).to eq(sample_id)  # id should match found mobile
+        expect(mobile[:data]).to have_key('manufacturer')
+        expect(mobile[:data]).to have_key('serial_number')
+        expect(mobile[:data]).to have_key('id')
+      end
+      it 'find_mobile: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_mobile(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found mobile
+      end
+      it 'update_mobile: update_mobile by id' do
+        sample_id = @mobiles.sample['id']
+        new_name = (0...50).map {('a'..'z').to_a[rand(26)] }.join
+        json = {
+          :mobile => {
+            :manufacturer => new_name
+          }
+        }
+        mobile_update = @samanage.update_mobile(payload: json, id: sample_id)
+        expect(mobile_update[:data]["manufacturer"]).to eq(new_name)
+        expect(mobile_update[:code]).to eq(200).or(201)
+      end
+      it 'deletes a valid mobile' do
         sample_mobile_id = @mobiles.sample['id']
         mobile_delete = @samanage.delete_mobile(id: sample_mobile_id)
         expect(mobile_delete[:code]).to eq(200).or(201)
       end
-      it 'fails to delete invalid mobile' do 
-        invalid_mobile_id = 0
-        # expect{@samanage.delete_mobile(id: invalid_mobile_id)}.to raise_error(Samanage::NotFound)
-      end
-		end
-	end
+    end
+  end
 end

data/spec/api/samanage_other_asset_spec.rb

@@ -1,88 +1,84 @@
 require 'samanage'
 
 describe Samanage::Api do
-	context 'Other Assets' do
-		describe 'API Functions' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@other_assets = @samanage.get_other_assets[:data]
-		end
-			it 'get_other_assets: it returns API call of other_assets' do
-				api_call = @samanage.get_other_assets
-				expect(api_call).to be_a(Hash)
-				expect(api_call[:total_count]).to be_an(Integer)
-				expect(api_call).to have_key(:response)
-				expect(api_call).to have_key(:code)
-			end
-			it 'collect_other_assets: collects array of other_assets' do
-				expect(@other_assets).to be_an(Array)
-			end
-			it 'create_other_asset(payload: json): creates a other_asset' do
-				other_asset_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				json = {
-					:other_asset => {
-						:name => other_asset_name,
-						:manufacturer => 'Samanage',
-						:asset_type => {:name => "Asset"},
-						:status => {:name => "Operational"}
-					}
-				}
+  context 'Other Assets' do
+    describe 'API Functions' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @other_assets = @samanage.get_other_assets[:data]
+    end
+      it 'get_other_assets: it returns API call of other_assets' do
+        api_call = @samanage.get_other_assets
+        expect(api_call).to be_a(Hash)
+        expect(api_call[:total_count]).to be_an(Integer)
+        expect(api_call).to have_key(:response)
+        expect(api_call).to have_key(:code)
+      end
+      it 'collect_other_assets: collects array of other_assets' do
+        expect(@other_assets).to be_an(Array)
+      end
+      it 'create_other_asset(payload: json): creates a other_asset' do
+        other_asset_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        json = {
+          :other_asset => {
+            :name => other_asset_name,
+            :manufacturer => 'Samanage',
+            :asset_type => {:name => "Asset"},
+            :status => {:name => "Operational"}
+          }
+        }
 
-				other_asset_create = @samanage.create_other_asset(payload: json)
-				expect(other_asset_create[:data]['id']).to be_an(Integer)
-				expect(other_asset_create[:data]['name']).to eq(other_asset_name)
-				expect(other_asset_create[:code]).to eq(200).or(201)
-			end
-			it 'create_other_asset: fails if wrong fields' do
-				other_asset_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				json = {
-					:other_asset => {
-						:name => other_asset_name,
-						:manufacturer => 'Samanage',
-						:asset_type => {:name => "Asset"},
-						:status => {:name => "Operational"}
-					}
-				}
-				json[:other_asset].delete(json[:other_asset].keys.sample) # Delete random sample from the examples above
-				expect{@samanage.create_other_asset(payload: json)}.to raise_error(Samanage::InvalidRequest)
-			end
+        other_asset_create = @samanage.create_other_asset(payload: json)
+        expect(other_asset_create[:data]['id']).to be_an(Integer)
+        expect(other_asset_create[:data]['name']).to eq(other_asset_name)
+        expect(other_asset_create[:code]).to eq(200).or(201)
+      end
+      it 'create_other_asset: fails if wrong fields' do
+        other_asset_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        json = {
+          :other_asset => {
+            :name => other_asset_name,
+            :manufacturer => 'Samanage',
+            :asset_type => {:name => "Asset"},
+            :status => {:name => "Operational"}
+          }
+        }
+        json[:other_asset].delete(json[:other_asset].keys.sample) # Delete random sample from the examples above
+        expect{@samanage.create_other_asset(payload: json)}.to raise_error(Samanage::InvalidRequest)
+      end
 
-			it 'find_other_asset: returns an other_asset card by known id' do
-				sample_id = @other_assets.sample['id']
+      it 'find_other_asset: returns an other_asset card by known id' do
+        sample_id = @other_assets.sample['id']
 
-				other_asset = @samanage.find_other_asset(id: sample_id)
+        other_asset = @samanage.find_other_asset(id: sample_id)
 
-				expect(other_asset[:data]['id']).to eq(sample_id)  # id should match found other_asset
-				expect(other_asset[:data]).to have_key('name')
-				expect(other_asset[:data]).to have_key('serial_number')
-				expect(other_asset[:data]).to have_key('id')
-			end
-			it 'find_other_asset: returns nothing for an invalid id' do
-				sample_id = (0..10).entries.sample
-				expect{@samanage.find_other_asset(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found other_asset
-			end
-			it 'update_other_asset: update_other_asset by id' do
-				sample_id = @other_assets.sample['id']
-				new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
-				json = {
-					:other_asset => {
-						:name => new_name
-					}
-				}
-				other_asset_update = @samanage.update_other_asset(payload: json, id: sample_id)
-				expect(other_asset_update[:data]["name"]).to eq(new_name)
-				expect(other_asset_update[:code]).to eq(200).or(201)
-			end
+        expect(other_asset[:data]['id']).to eq(sample_id)  # id should match found other_asset
+        expect(other_asset[:data]).to have_key('name')
+        expect(other_asset[:data]).to have_key('serial_number')
+        expect(other_asset[:data]).to have_key('id')
+      end
+      it 'find_other_asset: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_other_asset(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found other_asset
+      end
+      it 'update_other_asset: update_other_asset by id' do
+        sample_id = @other_assets.sample['id']
+        new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+        json = {
+          :other_asset => {
+            :name => new_name
+          }
+        }
+        other_asset_update = @samanage.update_other_asset(payload: json, id: sample_id)
+        expect(other_asset_update[:data]["name"]).to eq(new_name)
+        expect(other_asset_update[:code]).to eq(200).or(201)
+      end
       it 'deletes a valid other_asset' do
         sample_other_asset_id = @other_assets.sample['id']
         other_asset_delete = @samanage.delete_other_asset(id: sample_other_asset_id)
         expect(other_asset_delete[:code]).to eq(200).or(201)
-      end
-      it 'fails to delete invalid other_asset' do 
-        invalid_other_asset_id = 0
-        # expect{@samanage.delete_other_asset(id: invalid_other_asset_id)}.to raise_error(Samanage::NotFound)
-      end			
-		end
-	end
+      end      
+    end
+  end
 end

data/spec/api/samanage_site_spec.rb

@@ -1,50 +1,50 @@
 require 'samanage'
 describe Samanage::Api do
-	context 'Site' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@sites = @samanage.sites
-		end
-		it 'get_users: it returns API call of users' do
-			api_call = @samanage.get_sites
-			expect(api_call).to be_a(Hash)
-			expect(api_call[:total_count]).to be_an(Integer)
-			expect(api_call).to have_key(:response)
-			expect(api_call).to have_key(:code)
-		end
-		it 'collects all sites' do
-			sites = @sites
-			site_count = @samanage.get_sites[:total_count]
-			expect(sites).to be_an(Array)
-			expect(sites.size).to eq(site_count)
-		end
-		it 'creates a site' do
-			site_name = "Site ##{(rand*10**4).ceil}"
-			site_location = "Location #{(rand*10**4).ceil}"
-			site_description = "Descrption #{(rand*10**4).ceil}"
-			payload = {
-				site: {
-					name: site_name,
-					location: site_location,
-					description: site_description
-				}
-			}
-			site_create = @samanage.create_site(payload: payload)
+  context 'Site' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @sites = @samanage.sites
+    end
+    it 'get_users: it returns API call of users' do
+      api_call = @samanage.get_sites
+      expect(api_call).to be_a(Hash)
+      expect(api_call[:total_count]).to be_an(Integer)
+      expect(api_call).to have_key(:response)
+      expect(api_call).to have_key(:code)
+    end
+    it 'collects all sites' do
+      sites = @sites
+      site_count = @samanage.get_sites[:total_count]
+      expect(sites).to be_an(Array)
+      expect(sites.size).to eq(site_count)
+    end
+    it 'creates a site' do
+      site_name = "Site ##{(rand*10**4).ceil}"
+      site_location = "Location #{(rand*10**4).ceil}"
+      site_description = "Descrption #{(rand*10**4).ceil}"
+      payload = {
+        site: {
+          name: site_name,
+          location: site_location,
+          description: site_description
+        }
+      }
+      site_create = @samanage.create_site(payload: payload)
 
-			expect(site_create[:data]['id']).to be_an(Integer)
-			expect(site_create[:data]['name']).to eq(site_name)
-			expect(site_create[:code]).to eq(201).or(200)
-		end
-		it 'deletes a valid site' do
-			sample_site_id = @sites.sample['id']
-			site_delete = @samanage.delete_site(id: sample_site_id)
+      expect(site_create[:data]['id']).to be_an(Integer)
+      expect(site_create[:data]['name']).to eq(site_name)
+      expect(site_create[:code]).to eq(201).or(200)
+    end
+    it 'deletes a valid site' do
+      sample_site_id = @sites.sample['id']
+      site_delete = @samanage.delete_site(id: sample_site_id)
 
-			expect(site_delete[:code]).to eq(200).or(201)
-		end
-		it 'fails to delete invalid site' do 
-			invalid_site_id = 0
-			expect{@samanage.delete_site(id: invalid_site_id)}.to raise_error(Samanage::NotFound)
-		end
-	end
+      expect(site_delete[:code]).to eq(200).or(201)
+    end
+    it 'fails to delete invalid site' do 
+      invalid_site_id = 0
+      expect{@samanage.delete_site(id: invalid_site_id)}.to raise_error(Samanage::NotFound)
+    end
+  end
 end

data/spec/api/samanage_user_spec.rb

@@ -1,119 +1,136 @@
 require 'samanage'
 
 describe Samanage::Api do
-	context 'Users' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@users = @samanage.users
-		end
-		describe 'API Functions' do
-			it 'get_users: it returns API call of users' do
-				api_call = @samanage.get_users
-				expect(api_call).to be_a(Hash)
-				expect(api_call[:total_count]).to be_an(Integer)
-				expect(api_call).to have_key(:response)
-				expect(api_call).to have_key(:code)
-			end
-			it 'collect_users: collects array of users' do
-				user_count = @samanage.get_users[:total_count]
-				expect(@users).to be_an(Array)
-				expect(@users.size).to eq(user_count)
-			end
-			it 'create_user(payload: json): creates a user' do
-				user_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				email = user_name + "@samanage.com"
-				json = {
-					:user => {
-						:name => user_name,
-						:email => email,
-					}
-				}
-				user_create = @samanage.create_user(payload: json)
-				expect(user_create[:data]['email']).to eq(email)
-				expect(user_create[:data]['id']).to be_an(Integer)
-				expect(user_create[:data]['name']).to eq(user_name)
-				expect(user_create[:code]).to eq(200).or(201)
-			end
-			it 'create_user: fails if no email' do
-				user_name = "samanage-ruby-#{(rand*10**(rand(10))).ceil}"
-				json = {
-					:user => {
+  context 'Users' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN, development_mode: true)
+      @users = @samanage.users
+    end
+    describe 'API Functions' do
+      it 'ensures custom field is updated' do
+        val ="Random #{(rand*10**4).ceil}"
+        field_name = @samanage.custom_forms['user'][0]['custom_form_fields'].sample.dig('custom_field','name')
+        payload = {
+          user: {
+            custom_fields_values:{
+              custom_fields_value:[
+                { name: field_name, value: val}
+              ]
+            }
+          }
+        }
+        user_id = @users.sample.dig('id')
+        api_call = @samanage.update_user(id: user_id, payload: payload)
+        return_val = api_call.dig(:data,'custom_fields_values').select{|i| i['name'] == field_name}.first.to_h.dig('value')
+        expect(val).to eq(return_val)
+      end
+      it 'get_users: it returns API call of users' do
+        api_call = @samanage.get_users
+        expect(api_call).to be_a(Hash)
+        expect(api_call[:total_count]).to be_an(Integer)
+        expect(api_call).to have_key(:response)
+        expect(api_call).to have_key(:code)
+      end
+      it 'collect_users: collects array of users' do
+        user_count = @samanage.get_users[:total_count]
+        expect(@users).to be_an(Array)
+        expect(@users.size).to eq(user_count)
+      end
+      it 'create_user(payload: json): creates a user' do
+        user_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        email = user_name + "@samanage.com"
+        json = {
+          :user => {
             :name => user_name,
-					}
-				}
-				expect{@samanage.create_user(payload: json)}.to raise_error(Samanage::InvalidRequest)
-			end
-			it 'find_user: returns a user card by known id' do
-				sample_id = @users.sample['id']
-				user = @samanage.find_user(id: sample_id)
-				expect(user[:data]['id']).to eq(sample_id)  # id should match found user
-				expect(user[:data]).to have_key('email')
-				expect(user[:data]).to have_key('name')
-			end
+            :email => email,
+          }
+        }
+        user_create = @samanage.create_user(payload: json)
+        expect(user_create[:data]['email']).to eq(email)
+        expect(user_create[:data]['id']).to be_an(Integer)
+        expect(user_create[:data]['name']).to eq(user_name)
+        expect(user_create[:code]).to eq(200).or(201)
+      end
+      it 'create_user: fails if no email' do
+        user_name = "samanage-ruby-#{(rand*10**(rand(10))).ceil}"
+        json = {
+          :user => {
+            :name => user_name,
+          }
+        }
+        expect{@samanage.create_user(payload: json)}.to raise_error(Samanage::InvalidRequest)
+      end
+      it 'find_user: returns a user card by known id' do
+        sample_id = @users.sample['id']
+        user = @samanage.find_user(id: sample_id)
+        expect(user[:data]['id']).to eq(sample_id)  # id should match found user
+        expect(user[:data]).to have_key('email')
+        expect(user[:data]).to have_key('name')
+      end
 
 
-			it 'find_user: returns nothing for an invalid id' do
-				sample_id = (0..10).entries.sample
-				expect{@samanage.find_user(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found user
-			end
+      it 'find_user: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_user(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found user
+      end
 
-			it 'finds_user_id_by_email' do
-				sample_user = @users.sample
-				sample_email = sample_user['email']
-				sample_id = sample_user['id']
-				found_id = @samanage.find_user_id_by_email(email: sample_email)
-				expect(sample_email).not_to be(nil)
-				expect(sample_id).to eq(found_id)
-			end
+      it 'finds_user_id_by_email' do
+        sample_user = @users.sample
+        sample_email = sample_user['email']
+        sample_id = sample_user['id']
+        found_id = @samanage.find_user_id_by_email(email: sample_email)
+        expect(sample_email).not_to be(nil)
+        expect(sample_id).to eq(found_id)
+      end
 
-			it 'finds group_id for user' do
-				sample_user = @users.select{|u| u['role']['name'] == 'Administrator'}.sample
-				sample_user_email = sample_user['email']
-				group_ids = sample_user['group_ids']
-				found_id = nil
+      it 'finds group_id for user' do
+        sample_user = @users.select{|u| u['role']['name'] == 'Administrator'}.sample
+        sample_user_email = sample_user['email']
+        group_ids = sample_user['group_ids']
+        found_id = nil
 
-				group_ids.each do |group_id|
-					group = @samanage.find_group(id: group_id)
-					if group[:data]['is_user'] && sample_user_email == group[:data]['email']
-						found_id ||= group_id
-					end
-				end
-				function_id = @samanage.find_user_group_id_by_email(email: sample_user_email)
+        group_ids.each do |group_id|
+          group = @samanage.find_group(id: group_id)
+          if group[:data]['is_user'] && sample_user_email == group[:data]['email']
+            found_id ||= group_id
+          end
+        end
+        function_id = @samanage.find_user_group_id_by_email(email: sample_user_email)
 
-				expect(function_id).to eq(found_id)
-			end
+        expect(function_id).to eq(found_id)
+      end
 
 
-			it 'returns nil for invalid find_user_group_id_by_email' do
-				invalid_user_email = 'abc@123.gov'
-				function_id = @samanage.find_user_group_id_by_email(email: invalid_user_email)
+      it 'returns nil for invalid find_user_group_id_by_email' do
+        invalid_user_email = 'abc@123.gov'
+        function_id = @samanage.find_user_group_id_by_email(email: invalid_user_email)
 
-				expect(function_id).to be(nil)
-			end
+        expect(function_id).to be(nil)
+      end
 
-			it 'returns nil for invalid find_user_id_by_email' do
-				invalid_user_email = 'abc@123.gov'
-				function_id = @samanage.find_user_id_by_email(email: invalid_user_email)
+      it 'returns nil for invalid find_user_id_by_email' do
+        invalid_user_email = 'abc@123.gov'
+        function_id = @samanage.find_user_id_by_email(email: invalid_user_email)
 
-				expect(function_id).to be(nil)
-			end
+        expect(function_id).to be(nil)
+      end
 
 
 
-			it 'update_user: update_user by id' do
-				sample_id = @users.sample['id']
-				new_name = (0...25).map { ('a'..'z').to_a[rand(26)] }.join
-				json = {
-					:user => {
-						:name => new_name
-					}
-				}
-				user_update = @samanage.update_user(payload: json, id: sample_id)
-				expect(user_update[:data]["name"]).to eq(new_name)
-				expect(user_update[:code]).to eq(200).or(201)
-			end
-			it 'deletes a valid user' do
+      it 'update_user: update_user by id' do
+        sample_id = @users.sample['id']
+        new_name = (0...25).map { ('a'..'z').to_a[rand(26)] }.join
+        json = {
+          :user => {
+            :name => new_name
+          }
+        }
+        user_update = @samanage.update_user(payload: json, id: sample_id)
+        expect(user_update[:data]["name"]).to eq(new_name)
+        expect(user_update[:code]).to eq(200).or(201)
+      end
+      it 'deletes a valid user' do
         sample_user_id = @users.select{|u| !u['last_login']}.sample['id']
         user_delete = @samanage.delete_user(id: sample_user_id)
         expect(user_delete[:code]).to eq(200).or(201)
@@ -122,6 +139,6 @@ describe Samanage::Api do
         invalid_user_id = 0
         expect{@samanage.delete_user(id: invalid_user_id)}.to raise_error(Samanage::InvalidRequest)
       end
-		end
-	end
+    end
+  end
 end