samanage 2.1.19 → 2.1.20

data/spec/api/samanage_mobile_spec.rb

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

data/spec/api/samanage_other_asset_spec.rb

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

data/spec/api/samanage_problem_spec.rb

@@ -1,84 +1,91 @@
-require 'samanage'
-require 'faker'
+# frozen_string_literal: true
+
+require "samanage"
+require "faker"
 describe Samanage::Api do
-  context 'problems' do
-    describe 'API Functions' do
-    before(:all) do
-      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-      @samanage = Samanage::Api.new(token: TOKEN)
-      @problems = @samanage.problems
-      @users = @samanage.get_users[:data]
-    end
-      it 'get_problems: it returns API call of problems' do
+  context "problems" do
+    describe "API Functions" do
+      before(:all) do
+        TOKEN ||= ENV["SAMANAGE_TEST_API_TOKEN"]
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @problems = @samanage.problems
+        @users = @samanage.get_users[:data]
+      end
+      it "get_problems: it returns API call of problems" do
         api_call = @samanage.get_problems
         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_problems: collects array of problems' do
+      it "collect_problems: collects array of problems" do
         problem_count = @samanage.get_problems[:total_count]
         @problems = @samanage.problems
         expect(@problems).to be_an(Array)
         expect(@problems.size).to eq(problem_count)
       end
-      it 'create_problem(payload: json): creates a problem' do
-        users_email = @samanage.collect_users.sample['email']
+      it "create_problem(payload: json): creates a problem" do
+        users_email = @samanage.collect_users.sample["email"]
         problem_name = Faker::Book.title
         json = {
           problem: {
-            requester: {email: users_email},
+            requester: { email: users_email },
             name: problem_name,
-            state: 'Open',
-            priority: 'Low',
+            state: "Open",
+            priority: "Low",
             description: "Description"
           }
         }
         problem_create = @samanage.create_problem(payload: json)
 
-        expect(problem_create[:data]['id']).to be_an(Integer)
-        expect(problem_create[:data]['name']).to eq(problem_name)
+        expect(problem_create[:data]["id"]).to be_an(Integer)
+        expect(problem_create[:data]["name"]).to eq(problem_name)
         expect(problem_create[:code]).to eq(200).or(201)
       end
-      it 'create_problem: fails if no name/title' do
-        users_email = @users.sample['email']
+      it "create_problem: fails if no name/title" do
+        users_email = @users.sample["email"]
         json = {
-          :problem => {
-            :requester => {:email => users_email},
-            :description => "Description"
+          problem: {
+            requester: { email: users_email },
+            description: "Description"
           }
         }
-        expect{@samanage.create_problem(payload: json)}.to raise_error(Samanage::InvalidRequest)
+        expect {
+          @samanage.create_problem(payload: json)
+        }.to raise_error(Samanage::InvalidRequest)
       end
-      it 'find_problem: returns a problem card by known id' do
-        sample_id = @problems.sample['id']
+      it "find_problem: returns a problem card by known id" do
+        sample_id = @problems.sample["id"]
         problem = @samanage.find_problem(id: sample_id)
 
-        expect(problem[:data]['id']).to eq(sample_id)  # id should match found problem
-        expect(problem[:data]).to have_key('name')
-        expect(problem[:data]).to have_key('requester')
-        expect(problem[:data]).to have_key('id')
+        expect(problem[:data]["id"]).to eq(sample_id)  # id should match found problem
+        expect(problem[:data]).to have_key("name")
+        expect(problem[:data]).to have_key("requester")
+        expect(problem[:data]).to have_key("id")
       end
-      it 'find_problem: returns more keys with layout=long' do
-        sample_id = @problems.sample['id']
+      it "find_problem: returns more keys with layout=long" do
+        sample_id = @problems.sample["id"]
         layout_regular_problem = @samanage.find_problem(id: sample_id)
-        layout_long_problem = @samanage.find_problem(id: sample_id, options: {layout: 'long'})
+        layout_long_problem = @samanage.find_problem(id: sample_id, options: { layout: "long" })
 
-        expect(layout_long_problem[:data]['id']).to eq(sample_id)  # id should match found problem
+        expect(layout_long_problem[:data]["id"]).to eq(sample_id)  # id should match found problem
         expect(layout_long_problem[:data].keys.size).to be > (layout_regular_problem.keys.size)
         expect(layout_long_problem[:data].keys - layout_regular_problem[:data].keys).to_not be([])
       end
-      it 'find_problem: returns nothing for an invalid id' do
+      it "find_problem: returns nothing for an invalid id" do
         sample_id = (0..10).entries.sample
-        expect{@samanage.find_problem(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found problem
+        # id should match found problem
+        expect {
+          @samanage.find_problem(id: sample_id)
+        }.to raise_error(Samanage::NotFound)
       end
-      it 'update_problem: update_problem by id' do
-        sample_problem = @problems.reject{|i| ['Closed','Resolved'].include? i['state']}.sample
-        sample_id = sample_problem['id']
-        description = (0...500).map { ('a'..'z').to_a[rand(26)] }.join
+      it "update_problem: update_problem by id" do
+        sample_problem = @problems.reject { |i| ["Closed", "Resolved"].include? i["state"] }.sample
+        sample_id = sample_problem["id"]
+        description = (0...500).map { ("a".."z").to_a[rand(26)] }.join
         problem_json = {
-          :problem => {
-            :description => description
+          problem: {
+            description: description
           }
         }
         problem_update = @samanage.update_problem(payload: problem_json, id: sample_id)
@@ -86,12 +93,12 @@ describe Samanage::Api do
         expect(problem_update[:code]).to eq(200).or(201)
       end
       it 'finds more data for option[:layout] = "long"' do
-        full_layout_problem_keys = @samanage.problems(options: {layout: 'long'}).first.keys
+        full_layout_problem_keys = @samanage.problems(options: { layout: "long" }).first.keys
         basic_problem_keys = @samanage.problems.sample.keys
         expect(basic_problem_keys.size).to be < full_layout_problem_keys.size
       end
-      it 'deletes a valid problem' do
-        sample_problem_id = @problems.sample['id']
+      it "deletes a valid problem" do
+        sample_problem_id = @problems.sample["id"]
         problem_delete = @samanage.delete_problem(id: sample_problem_id)
         expect(problem_delete[:code]).to eq(200).or(201)
       end

data/spec/api/samanage_purchase_order_spec.rb

@@ -1,80 +1,83 @@
-require 'samanage'
-require 'faker'
+# frozen_string_literal: true
+
+require "samanage"
+require "faker"
 describe Samanage::Api do
-  context 'purchase_orders' do
-    describe 'API Functions' do
-    before(:all) do
-      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
-      @samanage = Samanage::Api.new(token: TOKEN)
-      @purchase_orders = @samanage.purchase_orders
-      @users = @samanage.get_users[:data]
-      @vendors = @samanage.get_vendors[:data]
-    end
-      it 'get_purchase_orders: it returns API call of purchase_orders' do
+  context "purchase_orders" do
+    describe "API Functions" do
+      before(:all) do
+        TOKEN ||= ENV["SAMANAGE_TEST_API_TOKEN"]
+        @samanage = Samanage::Api.new(token: TOKEN)
+        @purchase_orders = @samanage.purchase_orders
+        @users = @samanage.users
+        @vendors = @samanage.vendors
+      end
+      it "get_purchase_orders: it returns API call of purchase_orders" do
         api_call = @samanage.get_purchase_orders
         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_purchase_orders: collects array of purchase_orders' do
+      it "collect_purchase_orders: collects array of purchase_orders" do
         purchase_order_count = @samanage.get_purchase_orders[:total_count]
         @purchase_orders = @samanage.purchase_orders
         expect(@purchase_orders).to be_an(Array)
         expect(@purchase_orders.size).to eq(purchase_order_count)
       end
-      it 'create_purchase_order(payload: json): creates a purchase_order' do
-        users_email = @users.find{|u| u['role']['name']=='Administrator'}.to_h['email']
+      it "create_purchase_order(payload: json): creates a purchase_order" do
+        users_email = @users.find { |u| u["role"]["name"] == "Administrator" }.to_h["email"]
         purchase_order_name = Faker::Book.title
         json = {
           purchase_order: {
-            buyer: {email: users_email},
+            buyer: { email: users_email },
             name: purchase_order_name,
-            vendor: {name: @vendors.sample['name']}
+            vendor: { name: @vendors.sample["name"] }
           }
         }
         purchase_order_create = @samanage.create_purchase_order(payload: json)
-        expect(purchase_order_create[:data]['id']).to be_an(Integer)
-        expect(purchase_order_create[:data]['name']).to eq(purchase_order_name)
+        expect(purchase_order_create[:data]["id"]).to be_an(Integer)
+        expect(purchase_order_create[:data]["name"]).to eq(purchase_order_name)
         expect(purchase_order_create[:code]).to eq(200).or(201)
       end
-      it 'create_purchase_order: fails if no vendor' do
-        users_email = @users.sample['email']
+      it "create_purchase_order: fails if no vendor" do
+        users_email = @users.sample["email"]
         json = {
-          :purchase_order => {
-            :buyer => {:email => users_email},
-            :description => "Description"
+          purchase_order: {
+            buyer: { email: users_email },
+            description: "Description"
           }
         }
-        expect{@samanage.create_purchase_order(payload: json)}.to raise_error(Samanage::InvalidRequest)
+        expect { @samanage.create_purchase_order(payload: json) }.to raise_error(Samanage::InvalidRequest)
       end
-      it 'find_purchase_order: returns a purchase_order card by known id' do
-        sample_id = @purchase_orders.sample['id']
+      it "find_purchase_order: returns a purchase_order card by known id" do
+        sample_id = @purchase_orders.sample["id"]
         purchase_order = @samanage.find_purchase_order(id: sample_id)
-        expect(purchase_order[:data]['id']).to eq(sample_id)  # id should match found purchase_order
-        expect(purchase_order[:data]).to have_key('name')
-        expect(purchase_order[:data]).to have_key('id')
+        expect(purchase_order[:data]["id"]).to eq(sample_id)  # id should match found purchase_order
+        expect(purchase_order[:data]).to have_key("name")
+        expect(purchase_order[:data]).to have_key("id")
       end
 
-      it 'find_purchase_order: returns nothing for an invalid id' do
+      it "find_purchase_order: returns nothing for an invalid id" do
         sample_id = (0..10).entries.sample
-        expect{@samanage.find_purchase_order(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found purchase_order
+        # id should match found purchase_order
+        expect { @samanage.find_purchase_order(id: sample_id) }.to raise_error(Samanage::NotFound)
       end
-      it 'update_purchase_order: update_purchase_order by id' do
-        sample_purchase_order = @purchase_orders.reject{|i| ['Closed','Resolved'].include? i['state']}.sample
-        sample_id = sample_purchase_order['id']
-        description = (0...500).map { ('a'..'z').to_a[rand(26)] }.join
+      it "update_purchase_order: update_purchase_order by id" do
+        sample_purchase_order = @purchase_orders.reject { |i| ["Closed", "Resolved"].include? i["state"] }.sample
+        sample_id = sample_purchase_order["id"]
+        description = (0...500).map { ("a".."z").to_a[rand(26)] }.join
         purchase_order_json = {
-          :purchase_order => {
-            :description => description
+          purchase_order: {
+            description: description
           }
         }
         purchase_order_update = @samanage.update_purchase_order(payload: purchase_order_json, id: sample_id)
         # expect(purchase_order_update[:data]['description']).to eq(description) # purchase_order bug #00044569
         expect(purchase_order_update[:code]).to eq(200).or(201)
       end
-      it 'deletes a valid purchase_order' do
-        sample_purchase_order_id = @purchase_orders.sample['id']
+      it "deletes a valid purchase_order" do
+        sample_purchase_order_id = @purchase_orders.sample["id"]
         purchase_order_delete = @samanage.delete_purchase_order(id: sample_purchase_order_id)
         expect(purchase_order_delete[:code]).to eq(200).or(201)
       end