samanage 1.9.33 → 2.0.03

data/spec/api/samanage_change_spec.rb

@@ -0,0 +1,98 @@
+require 'samanage'
+describe Samanage::Api do
+  context 'changes' do
+    describe 'API Functions' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @changes = @samanage.changes
+      @users = @samanage.users
+    end
+      it 'get_changes: it returns API call of changes' do
+        api_call = @samanage.get_changes
+        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_changes: collects array of changes' do
+        change_count = @samanage.get_changes[:total_count]
+        @changes = @samanage.changes
+        expect(@changes).to be_an(Array)
+        expect(@changes.size).to eq(change_count)
+      end
+      it 'create_change(payload: json): creates a change' do
+        users_email = @samanage.collect_users.sample['email']
+        change_name = "Samanage Ruby change"
+        json = {
+          change: {
+            requester: {email: users_email},
+            name: change_name,
+            priority: 'Low',
+            description: "Description"
+          }
+        }
+        change_create = @samanage.create_change(payload: json)
+
+        expect(change_create[:data]['id']).to be_an(Integer)
+        expect(change_create[:data]['name']).to eq(change_name)
+        expect(change_create[:code]).to eq(200).or(201)
+      end
+      it 'create_change: fails if no name/title' do
+        users_email = @users.sample['email']
+        json = {
+          :change => {
+            :requester => {:email => users_email},
+            :description => "Description"
+          }
+        }
+        expect{@samanage.create_change(payload: json)}.to raise_error(Samanage::InvalidRequest)
+      end
+      it 'find_change: returns a change card by known id' do
+        sample_id = @changes.sample['id']
+        change = @samanage.find_change(id: sample_id)
+
+        expect(change[:data]['id']).to eq(sample_id)  # id should match found change
+        expect(change[:data]).to have_key('name')
+        expect(change[:data]).to have_key('requester')
+        expect(change[:data]).to have_key('id')
+      end
+      it 'find_change: returns more keys with layout=long' do
+        sample_id = @changes.sample['id']
+        layout_regular_change = @samanage.find_change(id: sample_id)
+        layout_long_change = @samanage.find_change(id: sample_id, options: {layout: 'long'})
+
+        expect(layout_long_change[:data]['id']).to eq(sample_id)  # id should match found change
+        expect(layout_long_change[:data].keys.size).to be > (layout_regular_change.keys.size)
+        expect(layout_long_change[:data].keys - layout_regular_change[:data].keys).to_not be([])
+      end
+      it 'find_change: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_change(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found change
+      end
+      it 'update_change: update_change by id' do
+        sample_change = @changes.reject{|i| ['Closed','Resolved'].include? i['state']}.sample
+        sample_id = sample_change['id']
+        description = (0...500).map { ('a'..'z').to_a[rand(26)] }.join
+        change_json = {
+          :change => {
+            :description => description
+          }
+        }
+        change_update = @samanage.update_change(payload: change_json, id: sample_id)
+        expect(change_update[:data]['description']).to eq(description)
+        expect(change_update[:code]).to eq(200).or(201)
+      end
+      it 'finds more data for option[:layout] = "long"' do
+        full_layout_change_keys = @samanage.changes(options: {layout: 'long'}).first.keys
+        basic_change_keys = @samanage.changes.sample.keys
+        expect(basic_change_keys.size).to be < full_layout_change_keys.size
+      end
+      it 'deletes a valid change' do
+        sample_change_id = @changes.sample['id']
+        change_delete = @samanage.delete_change(id: sample_change_id)
+        expect(change_delete[:code]).to eq(200).or(201)
+      end
+    end
+  end
+end

data/spec/api/samanage_comments_spec.rb

@@ -1,37 +1,30 @@
 require 'samanage'
 describe Samanage::Api do
-	context 'Comments' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@incidents = @samanage.get_incidents[:data]
-		end
-		describe 'API Functions' do
-			it 'gets comments' do
-				incident_id = @incidents.sample.dig('id')
-				comments = @samanage.get_comments(incident_id: incident_id)
-				expect(comments).to be_a(Hash)
-			end
+  context 'Comments' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @incidents = @samanage.get_incidents[:data]
+    end
+    describe 'API Functions' do
+      it 'gets comments' do
+        incident_id = @incidents.sample.dig('id')
+        comments = @samanage.get_comments(incident_id: incident_id)
+        expect(comments).to be_a(Hash)
+      end
 
-			it 'creates a comment' do
-				incident_id = @incidents.sample.dig('id')
-				rand_text = ('a'..'z').to_a.shuffle[0,8].join
-				comment = {
-					comment: {
-						body: rand_text,
-					}
-				}
-				api_call = @samanage.create_comment(incident_id: incident_id, comment: comment)
+      it 'creates a comment' do
+        incident_id = @incidents.sample.dig('id')
+        rand_text = ('a'..'z').to_a.shuffle[0,8].join
+        comment = {
+          comment: {
+            body: rand_text,
+          }
+        }
+        api_call = @samanage.create_comment(incident_id: incident_id, comment: comment)
 
-				expect(api_call.dig(:data,'body')).to eq(rand_text)
-			end
-
-			it 'collects all comments' do
-				incident_id = @incidents.sample.dig('id')
-				comments = @samanage.comments(incident_id: incident_id)
-				# Total count bug
-				# expect(comments).to be(Array)
-			end
-		end
-	end
+        expect(api_call.dig(:data,'body')).to eq(rand_text)
+      end
+    end
+  end
 end

data/spec/api/samanage_contract_spec.rb

@@ -5,71 +5,70 @@ describe Samanage::Api do
     describe 'API Fucntions' do
       before(:all) do 
         TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@samanage = Samanage::Api.new(token: TOKEN)
-				@contracts = @samanage.contracts
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @contracts = @samanage.contracts
       end
       it 'get_contracts: it returns API call of contracts' do
-				api_call = @samanage.get_contracts
-				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_contracts: collects array of contracts' do
-				contract_count = @samanage.get_contracts[:total_count]
-				expect(@contracts).to be_an(Array)
-				expect(@contracts.size).to eq(contract_count)
-			end
-			it 'create_contract(payload: json): creates a contract' do
-				manufacturer_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				random_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
-				json = {
-					contract: {
-						type: 'SoftwareLicense',
+        api_call = @samanage.get_contracts
+        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_contracts: collects array of contracts' do
+        contract_count = @samanage.get_contracts[:total_count]
+        expect(@contracts).to be_an(Array)
+        expect(@contracts.size).to eq(contract_count)
+      end
+      it 'create_contract(payload: json): creates a contract' do
+        random_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+        json = {
+          contract: {
+            type: 'SoftwareLicense',
             manufacturer_name: 'Adobe',
             status: 'Active',
-						name:  random_name,
-					}
-				}
-				contract_create = @samanage.create_contract(payload: json)
+            name:  random_name,
+          }
+        }
+        contract_create = @samanage.create_contract(payload: json)
 
-				expect(contract_create[:data]['id']).to be_an(Integer)
-				expect(contract_create[:data]['name']).to eq(random_name)
-			end
-			it 'create_contract: fails if no status' do
-				contract_name = "samanage-ruby-#{(rand*10**10).ceil}"
-				json = {
-					:contract => {
-						model: 'test',
-						manufacturer_name: contract_name,
-					}
-				}
-				expect{@samanage.create_contract(payload: json)}.to raise_error(Samanage::InvalidRequest)
-			end
-			it 'find_contract: returns a contract card by known id' do
-				sample_id = @contracts.sample['id']
-				contract = @samanage.find_contract(id: sample_id)
+        expect(contract_create[:data]['id']).to be_an(Integer)
+        expect(contract_create[:data]['name']).to eq(random_name)
+      end
+      it 'create_contract: fails if no status' do
+        contract_name = "samanage-ruby-#{(rand*10**10).ceil}"
+        json = {
+          :contract => {
+            model: 'test',
+            manufacturer_name: contract_name,
+          }
+        }
+        expect{@samanage.create_contract(payload: json)}.to raise_error(Samanage::InvalidRequest)
+      end
+      it 'find_contract: returns a contract card by known id' do
+        sample_id = @contracts.sample['id']
+        contract = @samanage.find_contract(id: sample_id)
 
-				expect(contract[:data]['id']).to eq(sample_id)  # id should match found contract
-				expect(contract[:data]).to have_key('manufacturer_name')
-				expect(contract[:data]).to have_key('name')
-				expect(contract[:data]).to have_key('id')
-			end
-			it 'find_contract: returns nothing for an invalid id' do
-				sample_id = (0..10).entries.sample
-				expect{@samanage.find_contract(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found contract
-			end
-			it 'update_contract: update_contract by id' do
-				sample_id = @contracts.sample['id']
-				new_name = (0...50).map {('a'..'z').to_a[rand(26)] }.join
-				json = {
-					contract: {
-						manufacturer_name: new_name
-					}
-				}
-				contract_update = @samanage.update_contract(payload: json, id: sample_id)
-				expect(contract_update[:data]["manufacturer_name"]).to eq(new_name)
-				expect(contract_update[:code]).to eq(200).or(201)
+        expect(contract[:data]['id']).to eq(sample_id)  # id should match found contract
+        expect(contract[:data]).to have_key('manufacturer_name')
+        expect(contract[:data]).to have_key('name')
+        expect(contract[:data]).to have_key('id')
+      end
+      it 'find_contract: returns nothing for an invalid id' do
+        sample_id = (0..10).entries.sample
+        expect{@samanage.find_contract(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found contract
+      end
+      it 'update_contract: update_contract by id' do
+        sample_id = @contracts.sample['id']
+        new_name = (0...50).map {('a'..'z').to_a[rand(26)] }.join
+        json = {
+          contract: {
+            manufacturer_name: new_name
+          }
+        }
+        contract_update = @samanage.update_contract(payload: json, id: sample_id)
+        expect(contract_update[:data]["manufacturer_name"]).to eq(new_name)
+        expect(contract_update[:code]).to eq(200).or(201)
       end
       it 'adds an item to a contract by id' do
         sample_id = @contracts.sample['id']
@@ -83,17 +82,12 @@ describe Samanage::Api do
         }
         add_item = @samanage.add_item_to_contract(id: sample_id, payload: item)
         expect(add_item[:code]).to eq(200).or(201)
-			end
-			it 'deletes a valid contract' do
+      end
+      it 'deletes a valid contract' do
         sample_contract_id = @contracts.sample['id']
         contract_delete = @samanage.delete_contract(id: sample_contract_id)
         expect(contract_delete[:code]).to eq(200).or(201)
       end
-      it 'fails to delete invalid contract' do 
-				invalid_contract_id = 01
-				abc = @samanage.delete_contract(id: invalid_contract_id)
-				# expect{@samanage.delete_contract(id: invalid_contract_id)}.to raise_error(Samanage::NotFound)
-      end
-		end
-	end
+    end
+  end
 end

data/spec/api/samanage_custom_field_spec.rb

@@ -1,16 +1,16 @@
 require 'samanage'
 
 describe Samanage::Api do
-	context 'Custom Field' do
-		describe 'API Functions' do
-			before(:all) do
-				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@samanage = Samanage::Api.new(token: TOKEN)
-				@custom_fields = @samanage.custom_fields
-			end
-			it 'collects all custom fields' do
-				expect(@custom_fields).to be_a(Array)
-			end
-		end
-	end
+  context 'Custom Field' do
+    describe 'API Functions' do
+      before(:all) do
+        TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @custom_fields = @samanage.custom_fields
+      end
+      it 'collects all custom fields' do
+        expect(@custom_fields).to be_a(Array)
+      end
+    end
+  end
 end

data/spec/api/samanage_custom_form_spec.rb

@@ -1,28 +1,28 @@
 require 'samanage'
 
 describe Samanage::Api do
-	context 'Custom Form' do
-		describe 'API Functions' do
-			before(:all) do
-				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@controller = Samanage::Api.new(token: TOKEN, development_mode: true)
-				@custom_forms = @controller.collect_custom_forms
-			end
-			it 'collects all custom forms' do
-				expect(@custom_forms).to be_a(Array)
-			end
-			it 'Organizes custom forms by module' do
-				api_call = @controller.organize_forms
-				expect(api_call).to be_a(Hash)
-				expect(api_call.keys).to be_an(Array)
-				# expect(api_call[api_call.keys.sample].sample).to be_a(Hash)
-			end
-			it 'Finds the forms for an object_type' do
-				object_types = ['incident', 'user','other_asset','hardware','configuration_item']
-				form = @controller.form_for(object_type: object_types.sample)
-				expect(form).to be_an(Array)
-				expect(form.sample.keys).to include('custom_form_fields')
-			end
-		end
-	end
+  context 'Custom Form' do
+    describe 'API Functions' do
+      before(:all) do
+        TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+        @controller = Samanage::Api.new(token: TOKEN, development_mode: true)
+        @custom_forms = @controller.collect_custom_forms
+      end
+      it 'collects all custom forms' do
+        expect(@custom_forms).to be_a(Array)
+      end
+      it 'Organizes custom forms by module' do
+        api_call = @controller.organize_forms
+        expect(api_call).to be_a(Hash)
+        expect(api_call.keys).to be_an(Array)
+        # expect(api_call[api_call.keys.sample].sample).to be_a(Hash)
+      end
+      it 'Finds the forms for an object_type' do
+        object_types = ['incident', 'user','other_asset','hardware','configuration_item']
+        form = @controller.form_for(object_type: object_types.sample)
+        expect(form).to be_an(Array)
+        expect(form.sample.keys).to include('custom_form_fields')
+      end
+    end
+  end
 end

data/spec/api/samanage_department_spec.rb

@@ -1,41 +1,40 @@
 require 'samanage'
 describe Samanage::Api do
-	context 'department' do
-		before(:all) do
-			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@samanage = Samanage::Api.new(token: TOKEN)
-			@departments = @samanage.departments
-		end
-		it 'get_users: it returns API call of departments' do
-			api_call = @samanage.get_departments
-			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 departments' do
-			department_count = @samanage.get_departments[:total_count]
-			expect(@departments).to be_an(Array)
-			expect(@departments.size).to eq(department_count)
-		end
-		it 'creates a department' do
-			department_name = "department ##{(rand*10**4).ceil}"
-			department_location = "Location #{(rand*10**4).ceil}"
-			department_description = "Location #{(rand*10**4).ceil}"
-			payload = {
-				department: {
-					name: department_name,
-					description: department_description
-				}
-			}
-			department_create = @samanage.create_department(payload: payload)
+  context 'department' do
+    before(:all) do
+      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      @samanage = Samanage::Api.new(token: TOKEN)
+      @departments = @samanage.departments
+    end
+    it 'get_users: it returns API call of departments' do
+      api_call = @samanage.get_departments
+      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 departments' do
+      department_count = @samanage.get_departments[:total_count]
+      expect(@departments).to be_an(Array)
+      expect(@departments.size).to eq(department_count)
+    end
+    it 'creates a department' do
+      department_name = "department ##{(rand*10**4).ceil}"
+      department_description = "Location #{(rand*10**4).ceil}"
+      payload = {
+        department: {
+          name: department_name,
+          description: department_description
+        }
+      }
+      department_create = @samanage.create_department(payload: payload)
 
-			expect(department_create[:data]['id']).to be_an(Integer)
-			expect(department_create[:data]['name']).to eq(department_name)
-			expect(department_create[:code]).to eq(201).or(200)
-		end
-		it 'deletes a valid department' do
-      sample_department_id = @departments.sample['id']
+      expect(department_create[:data]['id']).to be_an(Integer)
+      expect(department_create[:data]['name']).to eq(department_name)
+      expect(department_create[:code]).to eq(201).or(200)
+    end
+    it 'deletes a valid department' do
+      sample_department_id = @departments.sample.dig('id')
       department_delete = @samanage.delete_department(id: sample_department_id)
       expect(department_delete[:code]).to eq(200).or(201)
     end
@@ -43,5 +42,5 @@ describe Samanage::Api do
       invalid_department_id = 0
       expect{@samanage.delete_department(id: invalid_department_id)}.to raise_error(Samanage::NotFound)
     end
-	end
+  end
 end