samanage 1.9.33 → 2.0.03

data/spec/api/samanage_group_spec.rb

@@ -1,67 +1,67 @@
 require 'samanage'
 describe Samanage::Api do
-	context 'group' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@groups = @samanage.groups
-			@users = @samanage.get_users[:data]
-		end
-		it 'get_users: it returns API call of users' do
-			api_call = @samanage.get_groups
-			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 groups' do
-			group_count = @samanage.get_groups[:total_count]
-			expect(@groups).to be_an(Array)
-			expect(@groups.size).to eq(group_count)
-		end
-		it 'find_group: returns a group card by known id' do
-			sample_id = @groups.sample['id']
-			group = @samanage.find_group(id: sample_id)
-			expect(group[:data]['id']).to eq(sample_id)  # id should match found group
-			expect(group[:data]).to have_key('name')
-		end
-		it 'creates a group' do
-			group_name = "Group Name #{(rand*10**4).ceil}"
-			group_description = "Description #{(rand*10**4).ceil}"
-			payload = {
-				group: {
-					name: group_name,
-					description: group_description
-				}
-			}
-			group_create = @samanage.create_group(payload: payload)
+  context 'group' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @groups = @samanage.groups
+      @users = @samanage.get_users[:data]
+    end
+    it 'get_users: it returns API call of users' do
+      api_call = @samanage.get_groups
+      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 groups' do
+      group_count = @samanage.get_groups[:total_count]
+      expect(@groups).to be_an(Array)
+      expect(@groups.size).to eq(group_count)
+    end
+    it 'find_group: returns a group card by known id' do
+      sample_id = @groups.sample['id']
+      group = @samanage.find_group(id: sample_id)
+      expect(group[:data]['id']).to eq(sample_id)  # id should match found group
+      expect(group[:data]).to have_key('name')
+    end
+    it 'creates a group' do
+      group_name = "Group Name #{(rand*10**4).ceil}"
+      group_description = "Description #{(rand*10**4).ceil}"
+      payload = {
+        group: {
+          name: group_name,
+          description: group_description
+        }
+      }
+      group_create = @samanage.create_group(payload: payload)
 
-			expect(group_create[:data]['id']).to be_an(Integer)
-			expect(group_create[:data]['name']).to eq(group_name)
-			expect(group_create[:code]).to eq(200).or(201)
-		end
+      expect(group_create[:data]['id']).to be_an(Integer)
+      expect(group_create[:data]['name']).to eq(group_name)
+      expect(group_create[:code]).to eq(200).or(201)
+    end
 
-		it 'finds a group by name' do
-			group = @groups.sample
-			group_name = group['name']
-			group_id = group['id']
-			found_group_id = @samanage.find_group_id_by_name(group: group_name)
+    it 'finds a group by name' do
+      group = @groups.sample
+      group_name = group['name']
+      group_id = group['id']
+      found_group_id = @samanage.find_group_id_by_name(group: group_name)
 
-			expect(group_id).to eq(found_group_id)
-		end
-		it 'returns nil for finding invalid group by name' do
-			group_name = "Invalid-#{rand(100)*100}"
-			found_group_id = @samanage.find_group_id_by_name(group: group_name)
-			expect(found_group_id).to be(nil)
-		end
-		it 'adds member to group' do
-			random_group_id = @groups.sample['id']
-			random_user_email = @users.sample['email']
+      expect(group_id).to eq(found_group_id)
+    end
+    it 'returns nil for finding invalid group by name' do
+      group_name = "Invalid-#{rand(100)*100}"
+      found_group_id = @samanage.find_group_id_by_name(group: group_name)
+      expect(found_group_id).to be(nil)
+    end
+    it 'adds member to group' do
+      random_group_id = @groups.sample['id']
+      random_user_email = @users.sample['email']
 
-			add_user_to_group = @samanage.add_member_to_group(email: random_user_email, group_id: random_group_id)
-			expect(add_user_to_group[:code]).to eq(200).or(201)
-		end
-	  it 'deletes a valid group' do
+      add_user_to_group = @samanage.add_member_to_group(email: random_user_email, group_id: random_group_id)
+      expect(add_user_to_group[:code]).to eq(200).or(201)
+    end
+    it 'deletes a valid group' do
         sample_group_id = @groups.sample['id']
         group_delete = @samanage.delete_group(id: sample_group_id)
         expect(group_delete[:code]).to eq(200).or(201)
@@ -70,5 +70,5 @@ describe Samanage::Api do
         invalid_group_id = 0
         expect{@samanage.delete_group(id: invalid_group_id)}.to raise_error(Samanage::NotFound)
       end
-	end
+  end
 end

data/spec/api/samanage_hardware_spec.rb

@@ -1,95 +1,90 @@
 require 'samanage'
 describe Samanage::Api do
-	context 'Hardware' do
-		describe 'API Functions' do
-			before(:all) do
-				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@samanage = Samanage::Api.new(token: TOKEN)
-				@hardwares = @samanage.get_hardwares[:data]
-			end
-			it 'get_hardwares: it returns API call of hardwares' do
-				api_call = @samanage.get_hardwares
-				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_hardwares: collects array of hardwares' do
-				hardware_count = @samanage.get_hardwares[:total_count]
-				@hardwares = @samanage.hardwares
-				expect(@hardwares).to be_an(Array)
-				expect(@hardwares.size).to eq(hardware_count)
-			end
-			it 'create_hardware(payload: payload): creates a hardware' do
-				hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				serial_number = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
-				payload = {
-					:hardware => {
-						:name => hardware_name,
-						:bio => {:ssn => serial_number},
-					}
-				}
-				hardware_create = @samanage.create_hardware(payload: payload)
+  context 'Hardware' do
+    describe 'API Functions' do
+      before(:all) do
+        TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @hardwares = @samanage.get_hardwares[:data]
+      end
+      it 'get_hardwares: it returns API call of hardwares' do
+        api_call = @samanage.get_hardwares
+        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_hardwares: collects array of hardwares' do
+        hardware_count = @samanage.get_hardwares[:total_count]
+        @hardwares = @samanage.hardwares
+        expect(@hardwares).to be_an(Array)
+        expect(@hardwares.size).to eq(hardware_count)
+      end
+      it 'create_hardware(payload: payload): creates a hardware' do
+        hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        serial_number = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+        payload = {
+          :hardware => {
+            :name => hardware_name,
+            :bio => {:ssn => serial_number},
+          }
+        }
+        hardware_create = @samanage.create_hardware(payload: payload)
 
-				expect(hardware_create[:data]['id']).to be_an(Integer)
-				expect(hardware_create[:data]['name']).to eq(hardware_name)
-				expect(hardware_create[:code]).to eq(201).or(200)
-			end
-			it 'create_hardware: fails if no serial' do
-				hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				payload = {
-					:hardware => {
-						:name => hardware_name,
-					}
-				}
-				expect{@samanage.create_hardware(payload: payload)}.to raise_error(Samanage::InvalidRequest)
-			end
-			it 'find_hardware: returns a hardware card by known id' do
-				sample_id = @hardwares.sample['id']
-				hardware = @samanage.find_hardware(id: sample_id)
+        expect(hardware_create[:data]['id']).to be_an(Integer)
+        expect(hardware_create[:data]['name']).to eq(hardware_name)
+        expect(hardware_create[:code]).to eq(201).or(200)
+      end
+      it 'create_hardware: fails if no serial' do
+        hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        payload = {
+          :hardware => {
+            :name => hardware_name,
+          }
+        }
+        expect{@samanage.create_hardware(payload: payload)}.to raise_error(Samanage::InvalidRequest)
+      end
+      it 'find_hardware: returns a hardware card by known id' do
+        sample_id = @hardwares.sample['id']
+        hardware = @samanage.find_hardware(id: sample_id)
 
-				expect(hardware[:data]['id']).to eq(sample_id)  # id should match found hardware
-				expect(hardware[:data]).to have_key('name')
-				expect(hardware[:data]).to have_key('serial_number')
-				expect(hardware[:data]).to have_key('id')
-			end
-			it 'find_hardware: returns nothing for an invalid id' do
-				sample_id = (0..10).entries.sample
-				expect{@samanage.find_hardware(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found hardware
-			end
+        expect(hardware[:data]['id']).to eq(sample_id)  # id should match found hardware
+        expect(hardware[:data]).to have_key('name')
+        expect(hardware[:data]).to have_key('serial_number')
+        expect(hardware[:data]).to have_key('id')
+      end
+      it 'find_hardware: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_hardware(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found hardware
+      end
 
-			it 'finds_hardwares_by_serial' do
-				sample_hardware = @hardwares.sample
-				sample_serial_number = sample_hardware['serial_number']
-				sample_id = sample_hardware['id']
-				found_assets = @samanage.find_hardwares_by_serial(serial_number: sample_serial_number)
-				found_sample = found_assets[:data].sample
-				expect(sample_serial_number).not_to be(nil)
-				expect(found_sample['serial_number']).not_to be(nil)
-				expect(found_sample['serial_number']).to eq(sample_serial_number)
-				# expect(sample_id).to eq(found_assets[:data].first.dig('id'))
-			end
-			it 'update_hardware: update_hardware by id' do
-				sample_id = @hardwares.sample['id']
-				new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
-				payload = {
-					:hardware => {
-						:name => new_name
-					}
-				}
-				hardware_update = @samanage.update_hardware(payload: payload, id: sample_id)
-				expect(hardware_update[:data]["name"]).to eq(new_name)
-				expect(hardware_update[:code]).to eq(200).or(201)
-			end
-			it 'deletes a valid hardware' do
+      it 'finds_hardwares_by_serial' do
+        sample_hardware = @hardwares.sample
+        sample_serial_number = sample_hardware['serial_number']
+        found_assets = @samanage.find_hardwares_by_serial(serial_number: sample_serial_number)
+        found_sample = found_assets[:data].sample
+        expect(sample_serial_number).not_to be(nil)
+        expect(found_sample['serial_number']).not_to be(nil)
+        expect(found_sample['serial_number']).to eq(sample_serial_number)
+        # expect(sample_id).to eq(found_assets[:data].first.dig('id'))
+      end
+      it 'update_hardware: update_hardware by id' do
+        sample_id = @hardwares.sample['id']
+        new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+        payload = {
+          :hardware => {
+            :name => new_name
+          }
+        }
+        hardware_update = @samanage.update_hardware(payload: payload, id: sample_id)
+        expect(hardware_update[:data]["name"]).to eq(new_name)
+        expect(hardware_update[:code]).to eq(200).or(201)
+      end
+      it 'deletes a valid hardware' do
         sample_hardware_id = @hardwares.sample['id']
         hardware_delete = @samanage.delete_hardware(id: sample_hardware_id)
         expect(hardware_delete[:code]).to eq(200).or(201)
       end
-      it 'fails to delete invalid hardware' do 
-        invalid_hardware_id = 0
-        # expect{@samanage.delete_hardware(id: invalid_hardware_id)}.to raise_error(Samanage::NotFound)
-      end
-		end
-	end
+    end
+  end
 end

data/spec/api/samanage_incident_spec.rb

@@ -1,113 +1,109 @@
 require 'samanage'
 describe Samanage::Api do
-	context 'Incidents' do
-		describe 'API Functions' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@incidents = @samanage.incidents
-			@users = @samanage.users
-			@incidents_with_archives = @samanage.incidents(options: {audit_archives: true})
-		end
-			it 'get_incidents: it returns API call of incidents' do
-				api_call = @samanage.get_incidents
-				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_incidents: collects array of incidents' do
-				incident_count = @samanage.get_incidents[:total_count]
-				@incidents = @samanage.incidents
-				expect(@incidents).to be_an(Array)
-				expect(@incidents.size).to eq(incident_count)
-			end
-			it 'create_incident(payload: json): creates a incident' do
-				users_email = @samanage.collect_users.sample['email']
-				incident_name = "Samanage Ruby Incident"
-				json = {
-					:incident => {
-						:requester => {:email => users_email},
-						:name => incident_name,
-						:description => "Description"
-					}
-				}
-				incident_create = @samanage.create_incident(payload: json)
+  context 'Incidents' do
+    describe 'API Functions' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @incidents = @samanage.incidents
+      @users = @samanage.users
+      @incidents_with_archives = @samanage.incidents(options: {audit_archives: true})
+    end
+      it 'get_incidents: it returns API call of incidents' do
+        api_call = @samanage.get_incidents
+        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_incidents: collects array of incidents' do
+        incident_count = @samanage.get_incidents[:total_count]
+        @incidents = @samanage.incidents
+        expect(@incidents).to be_an(Array)
+        expect(@incidents.size).to eq(incident_count)
+      end
+      it 'create_incident(payload: json): creates a incident' do
+        users_email = @samanage.collect_users.sample['email']
+        incident_name = "Samanage Ruby Incident"
+        json = {
+          :incident => {
+            :requester => {:email => users_email},
+            :name => incident_name,
+            :description => "Description"
+          }
+        }
+        incident_create = @samanage.create_incident(payload: json)
 
-				expect(incident_create[:data]['id']).to be_an(Integer)
-				expect(incident_create[:data]['name']).to eq(incident_name)
-				expect(incident_create[:code]).to eq(200).or(201)
-			end
-			it 'create_incident: fails if no name/title' do
-				users_email = @users.sample['email']
-				json = {
-					:incident => {
-						:requester => {:email => users_email},
-						:description => "Description"
-					}
-				}
-				expect{@samanage.create_incident(payload: json)}.to raise_error(Samanage::InvalidRequest)
-			end
-			it 'find_incident: returns a incident card by known id' do
-				sample_id = @incidents.sample['id']
-				incident = @samanage.find_incident(id: sample_id)
+        expect(incident_create[:data]['id']).to be_an(Integer)
+        expect(incident_create[:data]['name']).to eq(incident_name)
+        expect(incident_create[:code]).to eq(200).or(201)
+      end
+      it 'create_incident: fails if no name/title' do
+        users_email = @users.sample['email']
+        json = {
+          :incident => {
+            :requester => {:email => users_email},
+            :description => "Description"
+          }
+        }
+        expect{@samanage.create_incident(payload: json)}.to raise_error(Samanage::InvalidRequest)
+      end
+      it 'find_incident: returns a incident card by known id' do
+        sample_id = @incidents.sample['id']
+        incident = @samanage.find_incident(id: sample_id)
 
-				expect(incident[:data]['id']).to eq(sample_id)  # id should match found incident
-				expect(incident[:data]).to have_key('name')
-				expect(incident[:data]).to have_key('requester')
-				expect(incident[:data]).to have_key('id')
-			end
-			it 'find_incident: returns more keys with layout=long' do
-				sample_id = @incidents.sample['id']
-				layout_regular_incident = @samanage.find_incident(id: sample_id)
-				layout_long_incident = @samanage.find_incident(id: sample_id, options: {layout: 'long'})
+        expect(incident[:data]['id']).to eq(sample_id)  # id should match found incident
+        expect(incident[:data]).to have_key('name')
+        expect(incident[:data]).to have_key('requester')
+        expect(incident[:data]).to have_key('id')
+      end
+      it 'find_incident: returns more keys with layout=long' do
+        sample_id = @incidents.sample['id']
+        layout_regular_incident = @samanage.find_incident(id: sample_id)
+        layout_long_incident = @samanage.find_incident(id: sample_id, options: {layout: 'long'})
 
-				expect(layout_long_incident[:data]['id']).to eq(sample_id)  # id should match found incident
-				expect(layout_long_incident[:data].keys.size).to be > (layout_regular_incident.keys.size)
-				expect(layout_long_incident[:data].keys - layout_regular_incident[:data].keys).to_not be([])
-			end
-			it 'find_incident: returns nothing for an invalid id' do
-				sample_id = (0..10).entries.sample
-				expect{@samanage.find_incident(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found incident
-			end
-			it 'update_incident: update_incident by id' do
-				sample_incident = @incidents.reject{|i| ['Closed','Resolved'].include? i['state']}.sample
-				sample_id = sample_incident['id']
-				description = (0...500).map { ('a'..'z').to_a[rand(26)] }.join
-				incident_json = {
-					:incident => {
-						:description => description
-					}
-				}
-				incident_update = @samanage.update_incident(payload: incident_json, id: sample_id)
-				expect(incident_update[:data]['description']).to eq(description)
-				expect(incident_update[:code]).to eq(200).or(201)
-			end
-			it 'finds more data for option[:layout] = "long"' do
-				full_layout_incident_keys = @samanage.incidents(options: {layout: 'long'}).first.keys
-				basic_incident_keys = @samanage.incidents.sample.keys
-				expect(basic_incident_keys.size).to be < full_layout_incident_keys.size
-			end
-			it 'finds more audit archives for option[:audit_archives] = true' do
-				incident_keys = @incidents_with_archives.sample.keys
-				expect(incident_keys).to include
-				('audits')
-			end
-			it 'finds audit archives for options: {audit_archives: true, layout: "long"}' do
-				full_incident_keys = @incidents_with_archives.sample.keys
-				basic_incident_keys = @incidents.sample.keys
-				expect(basic_incident_keys.size).to be < full_incident_keys.size
-				expect(full_incident_keys).to include('audits')
-			end
-			it 'deletes a valid incident' do
+        expect(layout_long_incident[:data]['id']).to eq(sample_id)  # id should match found incident
+        expect(layout_long_incident[:data].keys.size).to be > (layout_regular_incident.keys.size)
+        expect(layout_long_incident[:data].keys - layout_regular_incident[:data].keys).to_not be([])
+      end
+      it 'find_incident: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_incident(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found incident
+      end
+      it 'update_incident: update_incident by id' do
+        sample_incident = @incidents.reject{|i| ['Closed','Resolved'].include? i['state']}.sample
+        sample_id = sample_incident['id']
+        description = (0...500).map { ('a'..'z').to_a[rand(26)] }.join
+        incident_json = {
+          :incident => {
+            :description => description
+          }
+        }
+        incident_update = @samanage.update_incident(payload: incident_json, id: sample_id)
+        expect(incident_update[:data]['description']).to eq(description)
+        expect(incident_update[:code]).to eq(200).or(201)
+      end
+      it 'finds more data for option[:layout] = "long"' do
+        full_layout_incident_keys = @samanage.incidents(options: {layout: 'long'}).first.keys
+        basic_incident_keys = @samanage.incidents.sample.keys
+        expect(basic_incident_keys.size).to be < full_layout_incident_keys.size
+      end
+      it 'finds more audit archives for option[:audit_archives] = true' do
+        incident_keys = @incidents_with_archives.sample.keys
+        expect(incident_keys).to include
+        ('audits')
+      end
+      it 'finds audit archives for options: {audit_archives: true, layout: "long"}' do
+        full_incident_keys = @incidents_with_archives.sample.keys
+        basic_incident_keys = @incidents.sample.keys
+        expect(basic_incident_keys.size).to be < full_incident_keys.size
+        expect(full_incident_keys).to include('audits')
+      end
+      it 'deletes a valid incident' do
         sample_incident_id = @incidents.sample['id']
         incident_delete = @samanage.delete_incident(id: sample_incident_id)
         expect(incident_delete[:code]).to eq(200).or(201)
       end
-      it 'fails to delete invalid incident' do 
-        invalid_incident_id = 0
-        # expect{@samanage.delete_incident(id: invalid_incident_id)}.to raise_error(Samanage::NotFound)
-      end
-		end
-	end
+    end
+  end
 end