samanage 1.8.8 → 1.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4cedeeea723b8028baf7e86f24cd0fdc19e92ab1
-  data.tar.gz: e5c30e6130bed20c7ab1307af38fad03ecaad412
+  metadata.gz: 12aaeb776e072d9ce54b43f057110c940aa12be8
+  data.tar.gz: 6e825ba3089895f5552dc4fd5146d58fc8060602
 SHA512:
-  metadata.gz: 80188be6d78b1eab07e99d5a076485fed80ddd2ba7c2cfc400817a0df3173d7ec45252e7fdb88f096e61f0abcc4e9ad5b64652fcefbaa15a7695b1483cd9a12f
-  data.tar.gz: fda39d8acf665d196c624102ddb1aa50fdd6d01dcba93eb9e640a4a34894f4968d6a7186ea96e608f704cb6ecbec4d506199da70f09968391a80557e89777f3f
+  metadata.gz: cdf644e3b6496ff4a6b4eee7c75c189098f2d6f7bd673d49053f98f151e93d2a649abc70102380ce056de34b1866bd963f3136b168df78106771c417ee3c9323
+  data.tar.gz: 416eeccd82d3ba033211114872d5110fa74b72688b83aa93ba4e87eeb8b7d121082dc48e22499650b24700cfce0b28ac488d42e2afd7aee0fa80801395cc17a6

data/changelog.md

@@ -1,3 +1,6 @@
+# 1.8.9
+- Adding output verbosity for collection methods
+
 # 1.8.8
 - Base level .execute delete functionality
 - Error message for invalid http methods

data/lib/samanage/api/custom_fields.rb

@@ -8,13 +8,13 @@ module Samanage
 		end
 
 		# Gets all custom fields
-		def collect_custom_fields
+		def collect_custom_fields(options: {})
 			page = 1
 			custom_fields = Array.new
 			total_pages = self.get_custom_fields[:total_pages] ||= 2
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Custom Fields page: #{page}/#{total_pages}" if options[:verbose]
 				custom_fields += self.execute(path: "custom_fields.json")[:data]
-				page += 1
 			end
 			custom_fields
 		end

data/lib/samanage/api/custom_forms.rb

@@ -7,13 +7,13 @@ module Samanage
 		end
 
 		# Get all custom forms
-		def collect_custom_forms
+		def collect_custom_forms(options: {})
 			page = 1
 			custom_forms = Array.new
 			total_pages = self.get_custom_forms[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Custom Forms page: #{page}/#{total_pages}" if options[:verbose]
 				custom_forms += self.execute(http_method: 'get', path: "custom_forms.json?page=#{page}")[:data]
-				page += 1
 			end
 			custom_forms
 		end

data/lib/samanage/api/departments.rb

@@ -5,11 +5,12 @@ module Samanage
 			self.execute(path: url)
 		end
 
-		def collect_departments
+		def collect_departments(options: {})
 			page = 1
 			departments = Array.new
 			total_pages = self.get_departments[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Groups page: #{page}/#{total_pages}" if options[:verbose]
 				departments += self.execute(http_method: 'get', path: "departments.json?page=#{page}")[:data]
 				page += 1
 			end

data/lib/samanage/api/groups.rb

@@ -5,13 +5,13 @@ module Samanage
 			self.execute(path: url)
 		end
 
-		def collect_groups
+		def collect_groups(options: {})
 			page = 1
 			groups = Array.new
 			total_pages = self.get_groups[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Groups page: #{page}/#{total_pages}" if options[:verbose]
 				groups += self.execute(http_method: 'get', path: "groups.json?page=#{page}")[:data]
-				page += 1
 			end
 			groups
 		end

data/lib/samanage/api/hardwares.rb

@@ -8,13 +8,13 @@ module Samanage
 		end
 
 		# Get all hardwares
-		def collect_hardwares
+		def collect_hardwares(options: {})
 			page = 1
 			hardwares = Array.new
 			total_pages = self.get_hardwares[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Hardwares page: #{page}/#{total_pages}" if options[:verbose]
 				hardwares += self.execute(http_method: 'get', path: "hardwares.json?page=#{page}")[:data]
-				page += 1
 			end
 			hardwares
 		end

data/lib/samanage/api/incidents.rb

@@ -15,7 +15,9 @@ module Samanage
 		def collect_incidents(options: {})
 			incidents = Array.new
 			total_pages = self.get_incidents[:total_pages]
+			puts "Pulling Incidents with Audit Archives (this may take a while)" if options[:audit_archives] && options[:verbose]
 			1.upto(total_pages) do |page|
+				puts "Collecting Incidents page: #{page}/#{total_pages}" if options[:verbose]
 				if options[:audit_archives]
 					archives = 'layout=long&audit_archive=true'
 					paginated_incidents = self.execute(path: "incidents.json?page=#{page}")[:data]

data/lib/samanage/api/mobiles.rb

@@ -8,13 +8,13 @@ module Samanage
 		end
 
 		# Get all mobiles
-		def collect_mobiles
+		def collect_mobiles(options: {})
 			page = 1
 			mobiles = Array.new
 			total_pages = self.get_mobiles[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Mobiles page: #{page}/#{total_pages}" if options[:verbose]
 				mobiles += self.execute(http_method: 'get', path: "mobiles.json?page=#{page}")[:data]
-				page += 1
 			end
 			mobiles
 		end

data/lib/samanage/api/other_assets.rb

@@ -8,14 +8,14 @@ module Samanage
 		end
 
 		# Returns all other assets
-		def collect_other_assets
+		def collect_other_assets(options: {})
 			page = 1
 			other_assets = Array.new
 			total_pages = self.get_other_assets[:total_pages]
 			other_assets = []
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Other Assets page: #{page}/#{total_pages}" if options[:verbose]
 				other_assets += self.execute(http_method: 'get', path: "other_assets.json?page=#{page}")[:data]
-				page += 1
 			end
 			other_assets.uniq
 		end

data/lib/samanage/api/sites.rb

@@ -5,13 +5,13 @@ module Samanage
 			self.execute(path: url)
 		end
 
-		def collect_sites
+		def collect_sites(options: {})
 			page = 1
 			sites = Array.new
 			total_pages = self.get_sites[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Sites page: #{page}/#{total_pages}" if options[:verbose]
 				sites += self.execute(http_method: 'get', path: "sites.json?page=#{page}")[:data]
-				page += 1
 			end
 			sites
 		end

data/lib/samanage/api/users.rb

@@ -8,13 +8,13 @@ module Samanage
 	end
 
   # Returns all users in the account
-		def collect_users
+		def collect_users(options: {})
 			page = 1
 			users = Array.new
 			total_pages = self.get_users[:total_pages]
-			while page <= total_pages
+			1.upto(total_pages) do |page|
+				puts "Collecting Users page: #{page}/#{total_pages}" if options[:verbose]
 				users += self.execute(http_method: 'get', path: "users.json?page=#{page}")[:data]
-				page += 1
 			end
 			users
 		end

data/lib/samanage/version.rb

@@ -1,3 +1,3 @@
 module Samanage
-  VERSION = '1.8.8'
+  VERSION = '1.8.9'
 end

data/spec/api/samanage_category_spec.rb

@@ -1,13 +1,13 @@
 require 'samanage'
 describe Samanage::Api do
 	context 'category' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
+			@categories = @samanage.categories
 		end
 		it 'collects all categories' do
-			categories = @controller.collect_categories
-			expect(categories).to be_an(Array)
+			expect(@categories).to be_an(Array)
 		end
 
 		it 'creates a category' do
@@ -19,7 +19,7 @@ describe Samanage::Api do
 					description: category_description
 				}
 			}
-			category_create = @controller.create_category(payload: payload)
+			category_create = @samanage.create_category(payload: payload)
 
 			expect(category_create[:data]['id']).to be_an(Integer)
 			expect(category_create[:data]['name']).to eq(category_name)

data/spec/api/samanage_comments_spec.rb

@@ -1,35 +1,35 @@
 require 'samanage'
 describe Samanage::Api do
 	context 'Comments' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
 		end
 		describe 'API Functions' do
 			it 'gets comments' do
-				incident_id = @controller.get_incidents()[:data].sample.dig('id')
-				comments = @controller.get_comments(incident_id: incident_id)
+				incident_id = @samanage.get_incidents()[:data].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 = @controller.get_incidents()[:data].sample.dig('id')
+				incident_id = @samanage.get_incidents()[:data].sample.dig('id')
 				rand_text = ('a'..'z').to_a.shuffle[0,8].join
 				comment = {
 					comment: {
 						body: rand_text,
 					}
 				}
-				api_call = @controller.create_comment(incident_id: incident_id, comment: comment)
+				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 = @controller.get_incidents()[:data].sample.dig('id')
+				## incident_id = @samanage.get_incidents()[:data].sample.dig('id')
 				# incident_id = 19394209
-				# comments_api = @controller.get_comments(incident_id: incident_id)
-				# comments_found = @controller.collect_comments(incident_id: incident_id)
+				# comments_api = @samanage.get_comments(incident_id: incident_id)
+				# comments_found = @samanage.collect_comments(incident_id: incident_id)
 
 				# Total count bug
 				# expect(comments_api[:total_count]).to eq(comments_found.size)

data/spec/api/samanage_custom_field_spec.rb

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

data/spec/api/samanage_custom_form_spec.rb

@@ -3,13 +3,13 @@ require 'samanage'
 describe Samanage::Api do
 	context 'Custom Form' do
 		describe 'API Functions' do
-			before(:each) 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
-				api_call = @controller.collect_custom_forms
-				expect(api_call).to be_a(Array)
+				expect(@custom_forms).to be_a(Array)
 			end
 			it 'Organizes custom forms by module' do
 				api_call = @controller.organize_forms

data/spec/api/samanage_department_spec.rb

@@ -1,22 +1,22 @@
 require 'samanage'
 describe Samanage::Api do
 	context 'department' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
+			@departments = @samanage.departments
 		end
-		it 'get_users: it returns API call of users' do
-			api_call = @controller.get_departments
+		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
-			departments = @controller.collect_departments
-			department_count = @controller.get_departments[:total_count]
-			expect(departments).to be_an(Array)
-			expect(departments.size).to eq(department_count)
+			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}"
@@ -28,7 +28,7 @@ describe Samanage::Api do
 					description: department_description
 				}
 			}
-			department_create = @controller.create_department(payload: payload)
+			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)

data/spec/api/samanage_group_spec.rb

@@ -1,27 +1,27 @@
 require 'samanage'
 describe Samanage::Api do
 	context 'group' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
+			@groups = @samanage.groups
+			@users = @samanage.users
 		end
 		it 'get_users: it returns API call of users' do
-			api_call = @controller.get_groups
+			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
-			groups = @controller.collect_groups
-			group_count = @controller.get_groups[:total_count]
-			expect(groups).to be_an(Array)
-			expect(groups.size).to eq(group_count)
+			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
-			groups = @controller.collect_groups
-			sample_id = groups.sample['id']
-			group = @controller.find_group(id: sample_id)
+			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
@@ -34,7 +34,7 @@ describe Samanage::Api do
 					description: group_description
 				}
 			}
-			group_create = @controller.create_group(payload: payload)
+			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)
@@ -42,23 +42,23 @@ describe Samanage::Api do
 		end
 
 		it 'finds a group by name' do
-			group = @controller.collect_groups.sample
+			group = @groups.sample
 			group_name = group['name']
 			group_id = group['id']
-			found_group_id = @controller.find_group_id_by_name(group: group_name)
+			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 = @controller.find_group_id_by_name(group: group_name)
+			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 = @controller.collect_groups.sample['id']
-			random_user_email = @controller.collect_users.sample['email']
+			random_group_id = @groups.sample['id']
+			random_user_email = @users.sample['email']
 
-			add_user_to_group = @controller.add_member_to_group(email: random_user_email, group_id: random_group_id)
+			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
 	end

data/spec/api/samanage_hardware_spec.rb

@@ -2,22 +2,23 @@ require 'samanage'
 describe Samanage::Api do
 	context 'Hardware' do
 		describe 'API Functions' do
-			before(:each) do
+			before(:all) do
 				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@controller = Samanage::Api.new(token: TOKEN)
+				@samanage = Samanage::Api.new(token: TOKEN)
+				@hardwares = @samanage.hardwares
 			end
 			it 'get_hardwares: it returns API call of hardwares' do
-				api_call = @controller.get_hardwares
+				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
-				hardwares = @controller.collect_hardwares
-				hardware_count = @controller.get_hardwares[:total_count]
-				expect(hardwares).to be_an(Array)
-				expect(hardwares.size).to eq(hardware_count)
+				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}"
@@ -28,7 +29,7 @@ describe Samanage::Api do
 						:bio => {:ssn => serial_number},
 					}
 				}
-				hardware_create = @controller.create_hardware(payload: payload)
+				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)
@@ -41,12 +42,11 @@ describe Samanage::Api do
 						:name => hardware_name,
 					}
 				}
-				expect{@controller.create_hardware(payload: payload)}.to raise_error(Samanage::InvalidRequest)
+				expect{@samanage.create_hardware(payload: payload)}.to raise_error(Samanage::InvalidRequest)
 			end
 			it 'find_hardware: returns a hardware card by known id' do
-				hardwares = @controller.collect_hardwares
-				sample_id = hardwares.sample['id']
-				hardware = @controller.find_hardware(id: sample_id)
+				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')
@@ -55,15 +55,14 @@ describe Samanage::Api do
 			end
 			it 'find_hardware: returns nothing for an invalid id' do
 				sample_id = (0..10).entries.sample
-				expect{@controller.find_hardware(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found hardware
+				expect{@samanage.find_hardware(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found hardware
 			end
 
 			it 'finds_hardwares_by_serial' do
-				hardwares = @controller.collect_hardwares
-				sample_hardware = hardwares.sample
+				sample_hardware = @hardwares.sample
 				sample_serial_number = sample_hardware['serial_number']
 				sample_id = sample_hardware['id']
-				found_assets = @controller.find_hardwares_by_serial(serial_number: sample_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)
@@ -71,15 +70,14 @@ describe Samanage::Api do
 				# expect(sample_id).to eq(found_assets[:data].first.dig('id'))
 			end
 			it 'update_hardware: update_hardware by id' do
-				hardwares = @controller.collect_hardwares
-				sample_id = hardwares.sample['id']
+				sample_id = @hardwares.sample['id']
 				new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
 				payload = {
 					:hardware => {
 						:name => new_name
 					}
 				}
-				hardware_update = @controller.update_hardware(payload: payload, id: sample_id)
+				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

data/spec/api/samanage_incident_spec.rb

@@ -2,25 +2,28 @@ require 'samanage'
 describe Samanage::Api do
 	context 'Incidents' do
 		describe 'API Functions' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: 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 = @controller.get_incidents
+				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
-				incidents = @controller.collect_incidents
-				incident_count = @controller.get_incidents[:total_count]
-				expect(incidents).to be_an(Array)
-				expect(incidents.size).to eq(incident_count)
+				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 = @controller.collect_users.sample['email']
+				users_email = @samanage.collect_users.sample['email']
 				incident_name = "Samanage Ruby Incident"
 				json = {
 					:incident => {
@@ -29,26 +32,25 @@ describe Samanage::Api do
 						:description => "Description"
 					}
 				}
-				incident_create = @controller.create_incident(payload: json)
+				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 = @controller.collect_users.sample['email']
+				users_email = @users.sample['email']
 				json = {
 					:incident => {
 						:requester => {:email => users_email},
 						:description => "Description"
 					}
 				}
-				expect{@controller.create_incident(payload: json)}.to raise_error(Samanage::InvalidRequest)
+				expect{@samanage.create_incident(payload: json)}.to raise_error(Samanage::InvalidRequest)
 			end
 			it 'find_incident: returns a incident card by known id' do
-				incidents = @controller.collect_incidents
-				sample_id = incidents.sample['id']
-				incident = @controller.find_incident(id: sample_id)
+				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')
@@ -57,11 +59,10 @@ describe Samanage::Api do
 			end
 			it 'find_incident: returns nothing for an invalid id' do
 				sample_id = (0..10).entries.sample
-				expect{@controller.find_incident(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found incident
+				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
-				incidents = @controller.collect_incidents
-				sample_incident = incidents.reject{|i| ['Closed','Resolved'].include? i['state']}.sample
+				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 = {
@@ -69,22 +70,22 @@ describe Samanage::Api do
 						:description => description
 					}
 				}
-				incident_update = @controller.update_incident(payload: incident_json, id: sample_id)
+				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 = @controller.incidents(options: {layout: 'long'}).first.keys
-				basic_incident_keys = @controller.incidents.sample.keys
+				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 = @controller.incidents(options: {audit_archives: true}).sample.keys
+				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 = @controller.incidents(options: {audit_archives: true}).sample.keys
-				basic_incident_keys = @controller.incidents.sample.keys
+				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

data/spec/api/samanage_mobile_spec.rb

@@ -3,22 +3,22 @@ require 'samanage'
 describe Samanage::Api do
 	context 'Mobile' do
 		describe 'API Functions' do
-			before(:each) do
+			before(:all) do
 				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-				@controller = Samanage::Api.new(token: TOKEN)
+				@samanage = Samanage::Api.new(token: TOKEN)
+				@mobiles = @samanage.mobiles
 			end
 			it 'get_mobiles: it returns API call of mobiles' do
-				api_call = @controller.get_mobiles
+				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
-				mobiles = @controller.collect_mobiles
-				mobile_count = @controller.get_mobiles[:total_count]
-				expect(mobiles).to be_an(Array)
-				expect(mobiles.size).to eq(mobile_count)
+				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}"
@@ -30,7 +30,7 @@ describe Samanage::Api do
 						serial_number:  serial_number,
 					}
 				}
-				mobile_create = @controller.create_mobile(payload: json)
+				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)
@@ -43,12 +43,11 @@ describe Samanage::Api do
 						manufacturer: mobile_name,
 					}
 				}
-				expect{@controller.create_mobile(payload: json)}.to raise_error(Samanage::InvalidRequest)
+				expect{@samanage.create_mobile(payload: json)}.to raise_error(Samanage::InvalidRequest)
 			end
 			it 'find_mobile: returns a mobile card by known id' do
-				mobiles = @controller.collect_mobiles
-				sample_id = mobiles.sample['id']
-				mobile = @controller.find_mobile(id: sample_id)
+				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')
@@ -57,18 +56,17 @@ describe Samanage::Api do
 			end
 			it 'find_mobile: returns nothing for an invalid id' do
 				sample_id = (0..10).entries.sample
-				expect{@controller.find_mobile(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found mobile
+				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
-				mobiles = @controller.collect_mobiles
-				sample_id = mobiles.sample['id']
+				sample_id = @mobiles.sample['id']
 				new_name = (0...50).map {('a'..'z').to_a[rand(26)] }.join
 				json = {
 					:mobile => {
 						:manufacturer => new_name
 					}
 				}
-				mobile_update = @controller.update_mobile(payload: json, id: sample_id)
+				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

data/spec/api/samanage_other_asset_spec.rb

@@ -3,20 +3,20 @@ require 'samanage'
 describe Samanage::Api do
 	context 'Other Assets' do
 		describe 'API Functions' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
+			@other_assets = @samanage.other_assets
 		end
 			it 'get_other_assets: it returns API call of other_assets' do
-				api_call = @controller.get_other_assets
+				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
-				other_assets = @controller.collect_other_assets
-				expect(other_assets).to be_an(Array)
+				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}"
@@ -29,7 +29,7 @@ describe Samanage::Api do
 					}
 				}
 
-				other_asset_create = @controller.create_other_asset(payload: json)
+				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)
@@ -45,14 +45,13 @@ describe Samanage::Api do
 					}
 				}
 				json[:other_asset].delete(json[:other_asset].keys.sample) # Delete random sample from the examples above
-				expect{@controller.create_other_asset(payload: json)}.to raise_error(Samanage::InvalidRequest)
+				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
-				other_assets = @controller.collect_other_assets
-				sample_id = other_assets.sample['id']
+				sample_id = @other_assets.sample['id']
 
-				other_asset = @controller.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')
@@ -61,18 +60,17 @@ describe Samanage::Api do
 			end
 			it 'find_other_asset: returns nothing for an invalid id' do
 				sample_id = (0..10).entries.sample
-				expect{@controller.find_other_asset(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found other_asset
+				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
-				other_assets = @controller.collect_other_assets
-				sample_id = other_assets.sample['id']
+				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 = @controller.update_other_asset(payload: json, id: sample_id)
+				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

data/spec/api/samanage_site_spec.rb

@@ -1,20 +1,21 @@
 require 'samanage'
 describe Samanage::Api do
 	context 'Site' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
+			@sites = @samanage.sites
 		end
 		it 'get_users: it returns API call of users' do
-			api_call = @controller.get_sites
+			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 = @controller.collect_sites
-			site_count = @controller.get_sites[:total_count]
+			sites = @sites
+			site_count = @samanage.get_sites[:total_count]
 			expect(sites).to be_an(Array)
 			expect(sites.size).to eq(site_count)
 		end
@@ -29,7 +30,7 @@ describe Samanage::Api do
 					description: site_description
 				}
 			}
-			site_create = @controller.create_site(payload: payload)
+			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)

data/spec/api/samanage_user_spec.rb

@@ -2,23 +2,23 @@ require 'samanage'
 
 describe Samanage::Api do
 	context 'Users' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: 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 = @controller.get_users
+				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
-				users = @controller.collect_users
-				user_count = @controller.get_users[:total_count]
-				expect(users).to be_an(Array)
-				expect(users.size).to eq(user_count)
+				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}"
@@ -29,7 +29,7 @@ describe Samanage::Api do
 						:email => email,
 					}
 				}
-				user_create = @controller.create_user(payload: json)
+				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)
@@ -42,12 +42,11 @@ describe Samanage::Api do
             :name => user_name,
 					}
 				}
-				expect{@controller.create_user(payload: json)}.to raise_error(Samanage::InvalidRequest)
+				expect{@samanage.create_user(payload: json)}.to raise_error(Samanage::InvalidRequest)
 			end
 			it 'find_user: returns a user card by known id' do
-				users = @controller.collect_users
-				sample_id = users.sample['id']
-				user = @controller.find_user(id: sample_id)
+				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')
@@ -56,33 +55,31 @@ describe Samanage::Api do
 
 			it 'find_user: returns nothing for an invalid id' do
 				sample_id = (0..10).entries.sample
-				expect{@controller.find_user(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found user
+				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
-				users = @controller.collect_users
-				sample_user = users.sample
+				sample_user = @users.sample
 				sample_email = sample_user['email']
 				sample_id = sample_user['id']
-				found_id = @controller.find_user_id_by_email(email: sample_email)
+				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
-				users = @controller.collect_users
-				sample_user = users.select{|u| u['role']['name'] == 'Administrator'}.sample
+				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 = @controller.find_group(id: 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 = @controller.find_user_group_id_by_email(email: sample_user_email)
+				function_id = @samanage.find_user_group_id_by_email(email: sample_user_email)
 
 				expect(function_id).to eq(found_id)
 			end
@@ -90,14 +87,14 @@ describe Samanage::Api do
 
 			it 'returns nil for invalid find_user_group_id_by_email' do
 				invalid_user_email = 'abc@123.gov'
-				function_id = @controller.find_user_group_id_by_email(email: invalid_user_email)
+				function_id = @samanage.find_user_group_id_by_email(email: invalid_user_email)
 
 				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 = @controller.find_user_id_by_email(email: invalid_user_email)
+				function_id = @samanage.find_user_id_by_email(email: invalid_user_email)
 
 				expect(function_id).to be(nil)
 			end
@@ -105,15 +102,14 @@ describe Samanage::Api do
 
 
 			it 'update_user: update_user by id' do
-				users = @controller.collect_users
-				sample_id = users.sample['id']
+				sample_id = @users.sample['id']
 				new_name = (0...25).map { ('a'..'z').to_a[rand(26)] }.join
 				json = {
 					:user => {
 						:name => new_name
 					}
 				}
-				user_update = @controller.update_user(payload: json, id: sample_id)
+				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

data/spec/api/samanage_util_spec.rb

@@ -4,16 +4,17 @@ describe Samanage::Api do
     describe 'API Functions' do
       before(:each) do 
         TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-        @controller = Samanage::Api.new(token: TOKEN)
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @users = @samanage.users
       end
       it 'sends an activation email' do
-        valid_email = @controller.users.sample['email'] 
-        send_email = @controller.send_activation_email(email: valid_email)
+        valid_email = @users.sample['email'] 
+        send_email = @samanage.send_activation_email(email: valid_email)
         expect(send_email[:code]).to be(200)
       end
       it 'fails for invalid email' do
-        invalid_email = @controller.users.sample['email'].gsub!('@','$')
-        expect{@controller.send_activation_email(email: invalid_email)}.to raise_error(Samanage::Error)
+        invalid_email = @samanage.users.sample['email'].gsub!('@','$')
+        expect{@samanage.send_activation_email(email: invalid_email)}.to raise_error(Samanage::Error)
       end
     end
   end

data/spec/samanage_api_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 describe Samanage do
 	describe 'API Controller' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
 		end
-	  context 'on creation' do
-	  	it 'Requires Email & Token' do
+	  context 'on instantiation' do
+	  	it 'Requires Valid Token' do
 	  		expect{
 	  			api_controller = Samanage::Api.new(token: "invalid token")
 	  			api_controller.authorize

data/spec/samanage_category_spec.rb

@@ -1,14 +1,14 @@
 require 'samanage'
 describe Samanage::Api do
 	context 'category' do
-		before(:each) do
+		before(:all) do
 			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-			@controller = Samanage::Api.new(token: TOKEN)
+			@samanage = Samanage::Api.new(token: TOKEN)
+			@categories = @samanage.collect_categories
 		end
 		it 'collects all categories' do
-			categories = @controller.collect_categories
-			category_count = @controller.execute(path: 'categories.json')
-			expect(categories).to be_an(Array)
+			category_count = @samanage.execute(path: 'categories.json')
+			expect(@categories).to be_an(Array)
 		end
 
 		it 'creates a category' do
@@ -21,7 +21,7 @@ describe Samanage::Api do
 					description: category_description
 				}
 			}
-			category_create = @controller.create_category(payload: payload)
+			category_create = @samanage.create_category(payload: payload)
 
 			expect(category_create[:data]['id']).to be_an(Integer)
 			expect(category_create[:data]['name']).to eq(category_name)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: samanage
 version: !ruby/object:Gem::Version
-  version: 1.8.8
+  version: 1.8.9
 platform: ruby
 authors:
 - Chris Walls
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-05 00:00:00.000000000 Z
+date: 2018-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty