samanage 2.1.19 → 2.1.20

data/spec/api/samanage_custom_field_spec.rb

@@ -1,14 +1,16 @@
-require 'samanage'
+# frozen_string_literal: true
+
+require "samanage"
 
 describe Samanage::Api do
-  context 'Custom Field' do
-    describe 'API Functions' do
+  context "Custom Field" 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)
         @custom_fields = @samanage.custom_fields
       end
-      it 'collects all custom fields' do
+      it "collects all custom fields" do
         expect(@custom_fields).to be_a(Array)
       end
     end

data/spec/api/samanage_custom_form_spec.rb

@@ -1,27 +1,29 @@
-require 'samanage'
+# frozen_string_literal: true
+
+require "samanage"
 
 describe Samanage::Api do
-  context 'Custom Form' do
-    describe 'API Functions' do
+  context "Custom Form" do
+    describe "API Functions" do
       before(:all) do
-        TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+        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
+      it "collects all custom forms" do
         expect(@custom_forms).to be_an(Array)
       end
-      it 'Organizes custom forms by module' do
+      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']
+      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')
+        expect(form.sample.keys).to include("custom_form_fields")
       end
     end
   end

data/spec/api/samanage_department_spec.rb

@@ -1,26 +1,31 @@
-require 'samanage'
-require 'faker'
+# frozen_string_literal: true
+
+require "samanage"
+require "faker"
 describe Samanage::Api do
-  context 'department' do
+  context "department" do
     before(:all) do
-      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      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
+    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
+    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 = Faker::Book.title
+    it "creates a department" do
+      department_name = [
+        Faker::Internet.username,
+        Faker::Internet.domain_word
+      ].shuffle.join(' ')
       department_description = Faker::Book.author
       payload = {
         department: {
@@ -30,18 +35,18 @@ describe Samanage::Api do
       }
       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[:data]["id"]).to be_an(Integer)
+      expect(department_create[:data]["name"]).to eq(department_name)
       expect(department_create[:code]).to eq(200).or(201)
     end
-    it 'deletes a valid department' do
-      sample_department_id = @departments.sample.dig('id')
+    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
-    it 'fails to delete invalid department' do 
+    it "fails to delete invalid department" do
       invalid_department_id = 0
-      expect{@samanage.delete_department(id: invalid_department_id)}.to raise_error(Samanage::NotFound)
+      expect { @samanage.delete_department(id: invalid_department_id) }.to raise_error(Samanage::NotFound)
     end
   end
-end
+end

data/spec/api/samanage_group_spec.rb

@@ -1,32 +1,34 @@
-require 'faker'
-require 'samanage'
+# frozen_string_literal: true
+
+require "faker"
+require "samanage"
 describe Samanage::Api do
-  context 'group' do
+  context "group" do
     before(:all) do
-      TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+      TOKEN ||= ENV["SAMANAGE_TEST_API_TOKEN"]
       @samanage = Samanage::Api.new(token: TOKEN)
       @groups = @samanage.groups
       @users = @samanage.get_users[:data]
     end
-    it 'get_users: it returns API call of users' do
+    it "get_users: it returns API call of users" do
       api_call = @samanage.get_groups
       expect(api_call).to be_a(Hash)
       expect(api_call[:total_count]).to be_an(Integer)
       expect(api_call).to have_key(:response)
       expect(api_call).to have_key(:code)
     end
-    it 'collects all groups' do
+    it "collects all groups" do
       group_count = @samanage.get_groups[:total_count]
       expect(@groups).to be_an(Array)
       expect(@groups.size).to eq(group_count)
     end
-    it 'find_group: returns a group card by known id' do
-      sample_id = @groups.sample['id']
+    it "find_group: returns a group card by known id" do
+      sample_id = @groups.sample["id"]
       group = @samanage.find_group(id: sample_id)
-      expect(group[:data]['id']).to eq(sample_id)  # id should match found group
-      expect(group[:data]).to have_key('name')
+      expect(group[:data]["id"]).to eq(sample_id)  # id should match found group
+      expect(group[:data]).to have_key("name")
     end
-    it 'creates a group' do
+    it "creates a group" do
       group_name = Faker::BossaNova.artist
       group_description = Faker::BossaNova.song
       payload = {
@@ -37,38 +39,38 @@ describe Samanage::Api do
       }
       group_create = @samanage.create_group(payload: payload)
 
-      expect(group_create[:data]['id']).to be_an(Integer)
-      expect(group_create[:data]['name']).to eq(group_name)
+      expect(group_create[:data]["id"]).to be_an(Integer)
+      expect(group_create[:data]["name"]).to eq(group_name)
       expect(group_create[:code]).to eq(200).or(201)
     end
 
-    it 'finds a group by name' do
+    it "finds a group by name" do
       group = @groups.sample
-      group_name = group['name']
-      group_id = group['id']
+      group_name = group["name"]
+      group_id = group["id"]
       found_group_id = @samanage.find_group_id_by_name(group: group_name)
       expect(group_id).to eq(found_group_id)
     end
-    it 'returns nil for finding invalid group by name' do
-      group_name = "Invalid-#{rand(100)*100}"
+    it "returns nil for finding invalid group by name" do
+      group_name = "Invalid-#{rand(100) * 100}"
       found_group_id = @samanage.find_group_id_by_name(group: group_name)
       expect(found_group_id).to be(nil)
     end
-    it 'adds member to group' do
-      random_group_id = @groups.sample['id']
-      random_user_email = @users.sample['email']
+    it "adds member to group" do
+      random_group_id = @groups.sample["id"]
+      random_user_email = @users.sample["email"]
 
       add_user_to_group = @samanage.add_member_to_group(email: random_user_email, group_id: random_group_id)
       expect(add_user_to_group[:code]).to eq(200).or(201)
     end
-    it 'deletes a valid group' do
-        sample_group_id = @groups.sample['id']
+    it "deletes a valid group" do
+        sample_group_id = @groups.sample["id"]
         group_delete = @samanage.delete_group(id: sample_group_id)
         expect(group_delete[:code]).to eq(200).or(201)
       end
-      it 'fails to delete invalid group' do 
-        invalid_group_id = 0
-        expect{@samanage.delete_group(id: invalid_group_id)}.to raise_error(Samanage::NotFound)
-      end
+    it "fails to delete invalid group" do
+      invalid_group_id = 0
+      expect { @samanage.delete_group(id: invalid_group_id) }.to raise_error(Samanage::NotFound)
+    end
   end
-end
+end

data/spec/api/samanage_hardware_spec.rb

@@ -1,81 +1,87 @@
-require 'samanage'
-require 'faker'
+# frozen_string_literal: true
+
+require "samanage"
+require "faker"
 describe Samanage::Api do
-  context 'Hardware' do
-    describe 'API Functions' do
+  context "Hardware" 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)
         @hardwares = @samanage.get_hardwares[:data]
       end
-      it 'get_hardwares: it returns API call of hardwares' do
+      it "get_hardwares: it returns API call of hardwares" do
         api_call = @samanage.get_hardwares
         expect(api_call).to be_a(Hash)
         expect(api_call[:total_count]).to be_an(Integer)
         expect(api_call).to have_key(:response)
         expect(api_call).to have_key(:code)
       end
-      it 'collect_hardwares: collects array of hardwares' do
+      it "collect_hardwares: collects array of hardwares" do
         hardware_count = @samanage.get_hardwares[:total_count]
         @hardwares = @samanage.hardwares
         expect(@hardwares).to be_an(Array)
         expect(@hardwares.size).to eq(hardware_count)
       end
-      it 'create_hardware(payload: payload): creates a hardware' do
+      it "create_hardware(payload: payload): creates a hardware" do
         hardware_name = Faker::Science.scientist
         serial_number = Faker::Device.serial
         payload = {
-          :hardware => {
-            :name => hardware_name,
-            :bio => {:ssn => serial_number},
+          hardware: {
+            name: hardware_name,
+            bio: { ssn: serial_number },
           }
         }
         hardware_create = @samanage.create_hardware(payload: payload)
 
-        expect(hardware_create[:data]['id']).to be_an(Integer)
-        expect(hardware_create[:data]['name']).to eq(hardware_name)
+        expect(hardware_create[:data]["id"]).to be_an(Integer)
+        expect(hardware_create[:data]["name"]).to eq(hardware_name)
         expect(hardware_create[:code]).to eq(200).or(201)
       end
-      it 'create_hardware: fails if no serial' do
-        hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
+      it "create_hardware: fails if no serial" do
+        hardware_name = "samanage-ruby-#{(rand * 10**10).ceil}"
         payload = {
-          :hardware => {
-            :name => hardware_name,
+          hardware: {
+            name: hardware_name,
           }
         }
-        expect{@samanage.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
-        sample_id = @hardwares.sample['id']
+      it "find_hardware: returns a hardware card by known id" do
+        sample_id = @hardwares.sample["id"]
         hardware = @samanage.find_hardware(id: sample_id)
 
-        expect(hardware[:data]['id']).to eq(sample_id)  # id should match found hardware
-        expect(hardware[:data]).to have_key('name')
-        expect(hardware[:data]).to have_key('serial_number')
-        expect(hardware[:data]).to have_key('id')
+        expect(hardware[:data]["id"]).to eq(sample_id)  # id should match found hardware
+        expect(hardware[:data]).to have_key("name")
+        expect(hardware[:data]).to have_key("serial_number")
+        expect(hardware[:data]).to have_key("id")
       end
-      it 'find_hardware: returns nothing for an invalid id' do
+      it "find_hardware: returns nothing for an invalid id" do
         sample_id = (0..10).entries.sample
-        expect{@samanage.find_hardware(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found hardware
+        expect {
+          @samanage.find_hardware(id: sample_id)
+        }.to raise_error(Samanage::NotFound)  # id should match found hardware
       end
 
-      it 'finds_hardwares_by_serial' do
+      it "finds_hardwares_by_serial" do
         sample_hardware = @hardwares.sample
-        sample_serial_number = sample_hardware['serial_number']
+        sample_serial_number = sample_hardware["serial_number"]
         found_assets = @samanage.find_hardwares_by_serial(serial_number: sample_serial_number)
         found_sample = found_assets[:data].sample
         expect(sample_serial_number).not_to be(nil)
-        expect(found_sample['serial_number']).not_to be(nil)
-        expect(found_sample['serial_number']).to eq(sample_serial_number)
+        expect(found_sample["serial_number"]).not_to be(nil)
+        expect(found_sample["serial_number"]).to eq(sample_serial_number)
         # expect(sample_id).to eq(found_assets[:data].first.dig('id'))
       end
-      it 'update_hardware: update_hardware by id' do
-        sample_id = @hardwares.sample['id']
-        new_name = [Faker::Dune.planet,Faker::ProgrammingLanguage.name].join('-')
+      it "update_hardware: update_hardware by id" do
+        sample_id = @hardwares.sample["id"]
+        new_name = [Faker::Device.manufacturer, Faker::Device.platform].join("-")
         payload = {
-          :hardware => {
+          hardware: {
             name: new_name,
-            tag: Faker::Dune.saying,
+            tag: Faker::Books::Dune.saying,
             asset_id: Faker::Space.moon
           }
         }
@@ -83,11 +89,11 @@ describe Samanage::Api do
         expect(hardware_update[:data]["name"]).to eq(new_name)
         expect(hardware_update[:code]).to eq(200).or(201)
       end
-      it 'deletes a valid hardware' do
-        sample_hardware_id = @hardwares.sample['id']
+      it "deletes a valid hardware" do
+        sample_hardware_id = @hardwares.sample["id"]
         hardware_delete = @samanage.delete_hardware(id: sample_hardware_id)
         expect(hardware_delete[:code]).to eq(200).or(201)
       end
     end
   end
-end
+end

data/spec/api/samanage_incident_spec.rb

@@ -1,135 +1,153 @@
 # frozen_string_literal: true
 
-require 'samanage'
-require 'faker'
+require "samanage"
+require "faker"
 describe Samanage::Api do
-  context 'Incidents' do
-    describe 'API Functions' do
+  context "Incidents" 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)
         @incidents = @samanage.incidents
         @users = @samanage.users
-        @incidents_with_archives = @samanage.incidents(options: { audit_archives: true, layout: 'long', verbose: true })
+        @incidents_with_archives = @samanage.incidents(options: { audit_archives: true, layout: "long", verbose: true })
       end
-      it 'get_incidents: it returns API call of incidents' do
+      it "get_incidents: it returns API call of incidents" do
         api_call = @samanage.get_incidents
         expect(api_call).to be_a(Hash)
         expect(api_call[:total_count]).to be_an(Integer)
         expect(api_call).to have_key(:response)
         expect(api_call).to have_key(:code)
       end
-      it 'collect_incidents: collects array of incidents' do
+      it "collect_incidents: collects array of incidents" do
         incident_count = @samanage.get_incidents[:total_count]
         @incidents = @samanage.incidents
         expect(@incidents).to be_an(Array)
         expect(@incidents.size).to eq(incident_count)
       end
-      it 'create_incident(payload: json): creates a incident' do
-        users_email = @samanage.collect_users.sample['email']
-        incident_name = [Faker::StarWars.specie, Faker::StarWars.planet, Faker::StarWars.droid].shuffle.join(' ')
-        json = {
-          incident: {
-            requester: { email: users_email },
-            name: incident_name,
-            description: Faker::StarWars.quote
+      it "create_incident(payload: json): creates a incident" do
+        3.times {
+          users_email = @samanage.collect_users.sample["email"]
+          incident_name = [
+            Faker::Movies::StarWars.specie,
+            Faker::Movies::StarWars.planet,
+            Faker::Movies::StarWars.droid
+          ].shuffle.join(" ")
+          json = {
+            incident: {
+              requester: { email: users_email },
+              name: incident_name,
+              description: Faker::Movies::StarWars.quote
+            }
           }
-        }
-        incident_create = @samanage.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)
+          expect(incident_create[:data]["id"]).to be_an(Integer)
+          expect(incident_create[:data]["name"]).to eq(incident_name)
+          expect(incident_create[:code]).to eq(200).or(201)
+        }
       end
-      it 'create_incident: fails if no name/title' do
-        users_email = @users.sample['email']
+      it "create_incident: fails if no name/title" do
+        users_email = @users.sample["email"]
         json = {
           incident: {
             requester: { email: users_email },
-            description: Faker::StarWars.quote
+            description: Faker::Movies::StarWars.quote
           }
         }
         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']
+      it "find_incident: returns a incident card by known id" do
+        sample_id = @incidents.sample["id"]
         incident = @samanage.find_incident(id: sample_id)
 
-        expect(incident[:data]['id']).to eq(sample_id) # id should match found incident
-        expect(incident[:data]).to have_key('name')
-        expect(incident[:data]).to have_key('requester')
-        expect(incident[:data]).to have_key('id')
+        expect(incident[:data]["id"]).to eq(sample_id) # id should match found incident
+        expect(incident[:data]).to have_key("name")
+        expect(incident[:data]).to have_key("requester")
+        expect(incident[:data]).to have_key("id")
       end
-      it 'find_incident: returns more keys with layout=long' do
-        sample_id = @incidents.sample['id']
+      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]["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
+      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
+        # id should match found incident
+        expect {
+          @samanage.find_incident(id: sample_id)
+        }.to raise_error(Samanage::NotFound)
       end
-      it 'update_incident: update_incident by id' do
-        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
+      it "update_incident: update_incident by id" do
+        sample_incident = @incidents.reject { |i| %w[Closed Resolved].include? i["state"] }.sample
+        sample_id = sample_incident["id"]
+        description = [Faker::String.random, Faker::TvShows::Seinfeld.quote, Faker::Lorem.paragraph].sample
         incident_json = {
           incident: {
             description: description
           }
         }
         incident_update = @samanage.update_incident(payload: incident_json, id: sample_id)
-        expect(incident_update[:data]['description']).to eq(description)
+        expect(incident_update[:data]["description"]).to eq(description)
         expect(incident_update[:code]).to eq(200).or(201)
       end
       it 'finds more data for option[:layout] = "long"' do
-        full_layout_incident_keys = @samanage.incidents(options: { layout: 'long' }).first.keys
+        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
+      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
         basic_incident_keys = @incidents.sample.keys
         expect(basic_incident_keys.size).to be < full_incident_keys.size
-        expect(full_incident_keys).to include('audits')
+        expect(full_incident_keys).to include("audits")
       end
-      it 'deletes a valid incident' do
-        sample_incident_id = @incidents.sample['id']
+      it "deletes a valid incident" do
+        sample_incident_id = @incidents.sample["id"]
         incident_delete = @samanage.delete_incident(id: sample_incident_id)
         expect(incident_delete[:code]).to eq(200).or(201)
       end
-      it '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
+      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" })
+        user_email = @users.find { |u| u.dig("role", "name") == "Administrator" }.dig("email")
+        initial_email_audits = audits_req.dig(:data, "audits")
+          .select { |audit| audit["message"].match(/was sent./) }
+          .count
         incident_json = {
           incident: {
-            state: 'New',
-            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') }
+            state: "New",
+            # Must to configure email notifications for due date change
+            due_at: Date.new(2019, rand(1..11), rand(1..27)),
+            assignee: { email: user_email }
           }
         }
 
         @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' })
-        expect(origin_req[:data]).to have_key('origin')
+      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" }
+        )
+        expect(origin_req[:data]).to have_key("origin")
       end
     end
   end