samanage 2.1.18 → 2.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ffc172624f62a1fd88be55e019f8e60e578a74c1
-  data.tar.gz: a5ffc35b4b1b15c7e57f7ff41cab78915790b936
+SHA256:
+  metadata.gz: a13aff3441a2b195624d0ddd7f890f218cecd85949110dc1dd493e67c04b2c90
+  data.tar.gz: 279f7937d734914300265dd92d4144135eea997ac9282a721a6c696aaaf5b476
 SHA512:
-  metadata.gz: 2ba6fa8ce196713d263785ed9a45ea8e303b34c1134cc8a24b7cbdfe870d85d6e157a7f3b1d8825a0967bfe0f1256f4b7365de4a313cbf5fe53b3e1b8832c6df
-  data.tar.gz: ac4fcd8180ddb9beb45a5c6bf360be90bb459616d645ec8d51b8c693db2291af7e7ae2bbd0189069f02dde940ab6c8d859eef6806f6718e90bc50d86a78415a5
+  metadata.gz: e91607ebc97987f438434c4c99391bd68ef9c6e96eb7f31b63d9abb66516399ccc872be9d074ce863ba4ad59fe9b1a90773c39252daef27585c1f43a850d9cfd
+  data.tar.gz: d2b2f7890fb41e851a24caeb4101945f7bed0c3d933e397d1471eb22b19cbb69cd39309bd0b8b0038a7229f2fd284239a3ad86f74f7ee1cc1e3413832dfcb697

data/lib/samanage/api.rb

@@ -66,7 +66,7 @@ module Samanage
           end
         rescue => e
           puts "Invalid JSON: #{payload.inspect}"
-          raise Samanage::Error.new(error: e, response: nil)
+          raise Samanage::Error.new(error: e, response: nil, options: options)
         end
       end
       token = token ||= self.token
@@ -93,7 +93,7 @@ module Samanage
         when 'delete'
           api_call = self.class.delete(full_path, body: payload, headers: headers, query: options)
         else
-          raise Samanage::Error.new(response: {response: 'Unknown HTTP method'})
+          raise Samanage::Error.new(response: {response: 'Unknown HTTP method'}, options: options)
         end
       rescue Errno::ECONNREFUSED, Net::OpenTimeout, Errno::ETIMEDOUT, Net::ReadTimeout, OpenSSL::SSL::SSLError, Errno::ENETDOWN, Errno::ECONNRESET, Errno::ENOENT, EOFError, Net::HTTPTooManyRequests, SocketError => e
         retries += 1
@@ -104,7 +104,7 @@ module Samanage
         else
           error = e
           response = e.class
-          raise Samanage::InvalidRequest.new(error: error, response: response)
+          raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
         end
       rescue => e
         retries += 1
@@ -115,7 +115,7 @@ module Samanage
         else
           error = e
           response = e.class
-          raise Samanage::InvalidRequest.new(error: error, response: response)
+          raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
         end
       end
 
@@ -144,19 +144,19 @@ module Samanage
         response[:data] = api_call.body
         error = response[:response]
         self.authorized = false
-        raise Samanage::AuthorizationError.new(error: error,response: response)
+        raise Samanage::AuthorizationError.new(error: error,response: response, options: options)
       when 404
         response[:data] = api_call.body
         error = response[:response]
-        raise Samanage::NotFound.new(error: error, response: response)
+        raise Samanage::NotFound.new(error: error, response: response, options: options)
       when 422
         response[:data] = api_call.body
         error = response[:response]
-        raise Samanage::InvalidRequest.new(error: error, response: response)
+        raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
       else
         response[:data] = api_call.body
         error = response[:response]
-        raise Samanage::InvalidRequest.new(error: error, response: response)
+        raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
       end
     end
 

data/lib/samanage/api/attachments.rb

@@ -1,45 +1,43 @@
+# frozen_string_literal: true
+
 module Samanage
   class Api
     def download_attachment(attachment: {}, filename: nil, path: nil)
       attachable_type = attachment['attachable_type']
       attachable_id = attachment['attachable_id'].to_s
-      filename = filename || attachment['filename']
+      filename ||= attachment['filename']
       url = attachment['url']
-      
-      file_path = path ?  path : File.join(Dir.pwd,attachable_type,attachable_id)
-      unless File.directory?(file_path)
-        FileUtils.mkpath(file_path)
-      end
-      
-      exact_path = File.join(file_path,filename)
-      downloaded_attachment = open(exact_path, "wb+") do |file|
-        file << open(url).read
+
+      file_path = path || File.join(Dir.pwd, attachable_type, attachable_id)
+      FileUtils.mkpath(file_path) unless File.directory?(file_path)
+
+      exact_path = File.join(file_path, filename)
+      downloaded_attachment = File.open(exact_path, 'wb+') do |file|
+        file << URI.parse(url).read
       end
       downloaded_attachment
     end
 
-    def create_attachment(filepath: , attachable_type: , attachable_id: )
-      if !File.exists?(filepath)
+    def create_attachment(filepath:, attachable_type:, attachable_id:)
+      unless File.exist?(filepath)
         puts "Cannot find filepath: '#{filepath.inspect}'"
         return
       end
-      req = self.execute(
+      req = execute(
         path: 'attachments.json',
         http_method: 'post',
         multipart: true,
         payload: {
-          'file[attachable_type]' =>  attachable_type,
-          'file[attachable_id]' =>  attachable_id,
-          'file[attachment]' =>  File.open(filepath, 'rb')
+          'file[attachable_type]' => attachable_type,
+          'file[attachable_id]' => attachable_id,
+          'file[attachment]' => File.open(filepath, 'rb')
         },
         headers: {
           'Content-Type' => 'multipart/form-data',
-          'X-Samanage-Authorization' => 'Bearer ' + self.token
+          'X-Samanage-Authorization' => 'Bearer ' + token
         }
       )
       req
     end
-
-
   end
-end
+end

data/lib/samanage/api/incidents.rb

@@ -1,46 +1,38 @@
+# frozen_string_literal: true
+
 module Samanage
   class Api
-    
     # Default get incident path
     def get_incidents(path: PATHS[:incident], options: {})
-      
-      path = 'incidents.json?'
-      self.execute(path: path,options: options)
+      execute(path: path, options: options)
     end
 
-
-    # Returns all incidents. 
-    # Options: 
+    # Returns all incidents.
+    # Options:
     #   - audit_archives: true
     #   - layout: 'long'
     def collect_incidents(options: {})
-      incidents = Array.new
-      total_pages = self.get_incidents(options: options.except(:audit_archives,:audit_archive,:layout))[:total_pages]
-      puts "Requesting Incidents with Audit Archives (this may take a while)" if options[:audit_archives] && options[:verbose]
+      incidents = []
+      total_pages = get_incidents(options: options.except(:audit_archives, :audit_archive, :layout))[:total_pages]
+      puts 'Requesting 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]
+        options[:page] = page
         if options[:audit_archives]
-          options[:page] = page
-          params = URI.encode_www_form(options.except(:audit_archives,:audit_archive,:layout)) # layout not needed as audit only on individual record
-          paginated_path = "incidents.json?"
-          paginated_incidents = self.execute(path: paginated_path, options: options)[:data]
+          params = URI.encode_www_form(options.except(:audit_archives, :audit_archive, :layout)) # layout not needed as audit only on individual record
+          paginated_path = 'incidents.json?'
+          paginated_incidents = execute(path: paginated_path, options: options)[:data]
           paginated_incidents.map do |incident|
-            params = self.set_params(options: options.except(:audit_archives,:audit_archive,:layout))
+            params = set_params(options: options.except(:audit_archives, :audit_archive, :layout))
             archive_uri = "incidents/#{incident['id']}.json?layout=long&audit_archive=true"
-            incident_with_archive = self.execute(path: archive_uri)[:data]
-            if block_given?
-              yield incident_with_archive
-            end
+            incident_with_archive = execute(path: archive_uri)[:data]
+            yield incident_with_archive if block_given?
             incidents.push(incident_with_archive)
           end
         else
-          options[:page] = page
-          
-          path = "incidents.json?"
-          self.execute(path: path, options: options)[:data].each do |incident|
-            if block_given?
-              yield incident
-            end
+          path = 'incidents.json?'
+          execute(path: path, options: options)[:data].each do |incident|
+            yield incident if block_given?
             incidents.push(incident)
           end
         end
@@ -48,32 +40,27 @@ module Samanage
       incidents
     end
 
-
     # Create an incident given json
     def create_incident(payload: nil, options: {})
-      self.execute(path: PATHS[:incident], http_method: 'post', payload: payload, options: options)
+      execute(path: PATHS[:incident], http_method: 'post', payload: payload, options: options)
     end
 
     # Find incident by ID
-    def find_incident(id: , options: {})
-
-      
+    def find_incident(id:, options: {})
       path = "incidents/#{id}.json?"
-      self.execute(path: path, options: options)
+      execute(path: path, options: options)
     end
 
     # Update an incident given id and json
-    def update_incident(payload: , id: , options: {})
-      
+    def update_incident(payload:, id:, options: {})
       path = "incidents/#{id}.json?"
-      self.execute(path: path, http_method: 'put', payload: payload, options: options)
+      execute(path: path, http_method: 'put', payload: payload, options: options)
     end
 
-    def delete_incident(id: , options: {})
-      self.execute(path: "incidents/#{id}.json", http_method: 'delete', options: options)
+    def delete_incident(id:, options: {})
+      execute(path: "incidents/#{id}.json", http_method: 'delete', options: options)
     end
 
-
-  alias_method :incidents, :collect_incidents
+    alias incidents collect_incidents
   end
 end

data/lib/samanage/error.rb

@@ -11,7 +11,7 @@ module Samanage
         self.status_code = nil
         self.response = response
       end
-      puts "[Error] #{self.status_code}: #{self.response}" if options[:verbose]
+      puts "[Error] #{self.status_code}: #{self.response}"
       return
     end
   end

data/lib/samanage/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Samanage
-  VERSION = '2.1.18'
+  VERSION = '2.1.19'
 end

data/spec/api/samanage_incident_spec.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require 'samanage'
 require 'faker'
 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, layout: 'long', verbose: true})
-    end
+      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, layout: 'long', verbose: true })
+      end
       it 'get_incidents: it returns API call of incidents' do
         api_call = @samanage.get_incidents
         expect(api_call).to be_a(Hash)
@@ -25,12 +27,12 @@ describe Samanage::Api do
       end
       it 'create_incident(payload: json): creates a incident' do
         users_email = @samanage.collect_users.sample['email']
-        incident_name = [Faker::StarWars.specie,Faker::StarWars.planet,Faker::StarWars.droid].shuffle.join(' ')
+        incident_name = [Faker::StarWars.specie, Faker::StarWars.planet, Faker::StarWars.droid].shuffle.join(' ')
         json = {
-          :incident => {
-            :requester => {:email => users_email},
-            :name => incident_name,
-            :description => Faker::StarWars.quote
+          incident: {
+            requester: { email: users_email },
+            name: incident_name,
+            description: Faker::StarWars.quote
           }
         }
         incident_create = @samanage.create_incident(payload: json)
@@ -42,18 +44,18 @@ describe Samanage::Api do
       it 'create_incident: fails if no name/title' do
         users_email = @users.sample['email']
         json = {
-          :incident => {
-            :requester => {:email => users_email},
-            :description => Faker::StarWars.quote
+          incident: {
+            requester: { email: users_email },
+            description: Faker::StarWars.quote
           }
         }
-        expect{@samanage.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
         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]['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')
@@ -61,23 +63,23 @@ describe Samanage::Api do
       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'})
+        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]['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
+        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_incident = @incidents.reject { |i| %w[Closed Resolved].include? i['state'] }.sample
         sample_id = sample_incident['id']
-        description = [Faker::String.random,Faker::Seinfeld.quote,Faker::Lorem.paragraph].sample
+        description = [Faker::String.random, Faker::Seinfeld.quote, Faker::Lorem.paragraph].sample
         incident_json = {
-          :incident => {
-            :description => description
+          incident: {
+            description: description
           }
         }
         incident_update = @samanage.update_incident(payload: incident_json, id: sample_id)
@@ -85,14 +87,14 @@ describe Samanage::Api do
         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
+        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')
+        'audits'
       end
       it 'finds audit archives for options: {audit_archives: true, layout: "long"}' do
         full_incident_keys = @incidents_with_archives.first.keys
@@ -107,26 +109,26 @@ describe Samanage::Api do
       end
       it 'Sends an email if add_callbacks=true in params' do
         sample_id = @samanage.get_incidents[:data].sample['id']
-        audits_req = @samanage.find_incident(id: sample_id, options: {layout: 'long'})
-      
-        initial_email_audits = audits_req.dig(:data,'audits').select{|audit| audit['message'].match(/was sent./) }.count
+        audits_req = @samanage.find_incident(id: sample_id, options: { layout: 'long' })
+
+        initial_email_audits = audits_req.dig(:data, 'audits').select { |audit| audit['message'].match(/was sent./) }.count
         incident_json = {
-          :incident => {
+          incident: {
             state: 'New',
-            due_at: Date.new(2019,rand(11) + 1, rand(27) + 1), # need to configure email notifications for due date change
-            assignee: {email: @users.find{|u| u.dig('role','name') == 'Administrator'}.dig('email')}
+            due_at: Date.new(2019, rand(1..11), rand(1..27)), # need to configure email notifications for due date change
+            assignee: { email: @users.find { |u| u.dig('role', 'name') == 'Administrator' }.dig('email') }
           }
         }
-      
-        @samanage.update_incident(payload: incident_json, id: sample_id, options: {add_callbacks: true})
+
+        @samanage.update_incident(payload: incident_json, id: sample_id, options: { add_callbacks: true })
         sleep 5 # Wait for email to send
-        final_audits_req = @samanage.find_incident(id: sample_id, options: {layout: 'long'})
-        final_email_audits = final_audits_req.dig(:data,'audits').select{|audit| audit['message'].match(/was sent./) }.count
+        final_audits_req = @samanage.find_incident(id: sample_id, options: { layout: 'long' })
+        final_email_audits = final_audits_req.dig(:data, 'audits').select { |audit| audit['message'].match(/was sent./) }.count
         expect(initial_email_audits).to be < final_email_audits
       end
       it 'Finds incident origin in v2.0 layout=long header' do
         sample_id = @samanage.get_incidents[:data].sample['id']
-        origin_req = @samanage.execute(path: "incidents/#{sample_id}.json", verbose: true, headers: {'Accept' => "application/vnd.samanage.v2.0+json?layout=long"})
+        origin_req = @samanage.execute(path: "incidents/#{sample_id}.json", verbose: true, headers: { 'Accept' => 'application/vnd.samanage.v2.0+json?layout=long' })
         expect(origin_req[:data]).to have_key('origin')
       end
     end

data/spec/api/samanage_user_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'samanage'
 require 'faker'
 
@@ -12,20 +14,20 @@ describe Samanage::Api do
       it 'ensures custom field is updated' do
         val = Faker::Seinfeld.quote
         field_name = @samanage.custom_forms['user'][0]['custom_form_fields']
-          .select{|f|  f.dig('custom_field','field_type') == 1} # field_type == 1 is text
-          .sample.dig('custom_field','name')
+                              .select { |f| f.dig('custom_field', 'field_type') == 1 } # field_type == 1 is text
+                              .sample.dig('custom_field', 'name')
         payload = {
           user: {
-            custom_fields_values:{
-              custom_fields_value:[
-                { name: field_name, value: val}
+            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')
+        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
@@ -41,12 +43,12 @@ describe Samanage::Api do
         expect(@users.size).to eq(user_count)
       end
       it 'create_user(payload: json): creates a user' do
-        user_name = [Faker::Simpsons.character,Faker::StarWars.character,Faker::Name.name].sample
+        user_name = [Faker::Simpsons.character, Faker::StarWars.character, Faker::Name.name].sample
         email = Faker::Internet.safe_email(user_name)
         json = {
-          :user => {
-            :name => user_name,
-            :email => email,
+          user: {
+            name: user_name,
+            email: email
           }
         }
         user_create = @samanage.create_user(payload: json)
@@ -58,24 +60,23 @@ describe Samanage::Api do
       it 'create_user: fails if no email' do
         user_name = Faker::Superhero.name
         json = {
-          :user => {
-            :name => user_name,
+          user: {
+            name: user_name
           }
         }
-        expect{@samanage.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
         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]['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
+        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
@@ -88,7 +89,7 @@ describe Samanage::Api do
       end
 
       it 'finds group_id for user' do
-        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
@@ -104,7 +105,6 @@ describe Samanage::Api do
         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)
@@ -119,30 +119,28 @@ describe Samanage::Api do
         expect(function_id).to be(nil)
       end
 
-
-
       it 'update_user: update_user by id' do
         sample_id = @users.sample['id']
-        new_name = [Faker::Simpsons.character,Faker::StarWars.character,Faker::Name.name].sample
+        new_name = [Faker::Simpsons.character, Faker::StarWars.character, Faker::Name.name].sample
         json = {
-          :user => {
+          user: {
             name: new_name,
             title: Faker::Job.title
           }
         }
         user_update = @samanage.update_user(payload: json, id: sample_id)
-        expect(user_update[:data]["name"]).to eq(new_name)
+        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']
+        sample_user_id = @users.reject { |u| u['last_login'] }.sample['id']
         user_delete = @samanage.delete_user(id: sample_user_id)
         expect(user_delete[:code]).to eq(200).or(201)
       end
-      it 'fails to delete invalid user' do 
+      it 'fails to delete invalid user' do
         invalid_user_id = 0
-        expect{@samanage.delete_user(id: invalid_user_id)}.to raise_error(Samanage::InvalidRequest)
+        expect { @samanage.delete_user(id: invalid_user_id) }.to raise_error(Samanage::InvalidRequest)
       end
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: samanage
 version: !ruby/object:Gem::Version
-  version: 2.1.18
+  version: 2.1.19
 platform: ruby
 authors:
 - Chris Walls
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-30 00:00:00.000000000 Z
+date: 2019-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -130,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Samanage Ruby Gem