samanage 1.4

data/spec/api/samanage_custom_field_spec.rb

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

data/spec/api/samanage_custom_form_spec.rb

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

data/spec/api/samanage_hardware_spec.rb

@@ -0,0 +1,76 @@
+require 'samanage'
+
+describe Samanage::Api do
+	context 'Hardware' do
+		describe 'API Functions' do
+			before(:each) do
+				TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+				@controller = Samanage::Api.new(token: TOKEN)
+			end
+			it 'get_hardwares: it returns API call of hardwares' do
+				api_call = @controller.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)
+			end
+			it 'create_hardware(payload: json): creates a hardware' do
+				hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
+				serial_number = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+				json = {
+					:hardware => {
+						:name => hardware_name,
+						:bio => {:ssn => serial_number},
+					}
+				}
+				hardware_create = @controller.create_hardware(payload: json.to_json)
+
+				expect(hardware_create[:data]['id']).to be_an(Integer)
+				expect(hardware_create[:data]['name']).to eq(hardware_name)
+				expect(hardware_create[:code]).to eq(201).or(200)
+			end
+			it 'create_hardware: fails if no serial' do
+				hardware_name = "samanage-ruby-#{(rand*10**10).ceil}"
+				json = {
+					:hardware => {
+						:name => hardware_name,
+					}
+				}
+				expect{@controller.create_hardware(payload: json.to_json)}.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)
+
+				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
+				sample_id = (0..10).entries.sample
+				expect{@controller.find_hardware(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found hardware
+			end
+			it 'update_hardware: update_hardware by id' do
+				hardwares = @controller.collect_hardwares
+				sample_id = hardwares.sample['id']
+				new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+				json = {
+					:hardware => {
+						:name => new_name
+					}
+				}
+				hardware_update = @controller.update_hardware(payload: json.to_json, id: sample_id)
+				expect(hardware_update[:data]["name"]).to eq(new_name)
+				expect(hardware_update[:code]).to eq(200).or(201)
+			end
+		end
+	end
+end

data/spec/api/samanage_incident_spec.rb

@@ -0,0 +1,79 @@
+require 'samanage'
+
+describe Samanage::Api do
+	context 'Incidents' do
+		describe 'API Functions' do
+		before(:each) do
+			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+			@controller = Samanage::Api.new(token: TOKEN)
+		end
+			it 'get_incidents: it returns API call of incidents' do
+				api_call = @controller.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)
+			end
+			it 'create_incident(payload: json): creates a incident' do
+				users_email = @controller.collect_users.sample['email']
+				serial_number = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+				incident_name = "Samanage Ruby Incident"
+				json = {
+					:incident => {
+						:requester => {:email => users_email},
+						:name => incident_name,
+						:description => "Description"
+					}
+				}
+				incident_create = @controller.create_incident(payload: json.to_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']
+				json = {
+					:incident => {
+						:requester => {:email => users_email},
+						:description => "Description"
+					}
+				}
+				expect{@controller.create_incident(payload: json.to_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)
+
+				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 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
+			end
+			it 'update_incident: update_incident by id' do
+				incidents = @controller.collect_incidents
+				sample_id = incidents.sample['id']
+				new_name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+				json = {
+					:incident => {
+						:name => new_name
+					}
+				}
+				incident_update = @controller.update_incident(payload: json.to_json, id: sample_id)
+				expect(incident_update[:data]["name"]).to eq(new_name)
+				expect(incident_update[:code]).to eq(200).or(201)
+			end
+		end
+	end
+end

data/spec/api/samanage_other_asset_spec.rb

@@ -0,0 +1,84 @@
+require 'samanage'
+
+describe Samanage::Api do
+	context 'Other Assets' do
+		describe 'API Functions' do
+		before(:each) do
+			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+			@controller = Samanage::Api.new(token: TOKEN)
+		end
+			it 'get_other_assets: it returns API call of other_assets' do
+				api_call = @controller.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)
+			end
+			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_create = @controller.create_other_asset(payload: json.to_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)
+			end
+			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"}
+					}
+				}
+				json[:other_asset].delete(json[:other_asset].keys.sample) # Delete random sample from the examples above
+				expect{@controller.create_other_asset(payload: json.to_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
+				puts "Found ##{other_assets.size} other assets"
+				puts ".sample ##{other_assets.sample}"
+				puts ".sample['id'] ##{other_assets.sample['id']}"
+				sample_id = other_assets.sample['id']
+
+				other_asset = @controller.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')
+			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
+			end
+			it 'update_other_asset: update_other_asset by id' do
+				other_assets = @controller.collect_other_assets
+				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.to_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
+		end
+	end
+end

data/spec/api/samanage_user_spec.rb

@@ -0,0 +1,74 @@
+require 'samanage'
+
+describe Samanage::Api do
+	context 'Users' do
+		before(:each) do
+			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+			@controller = Samanage::Api.new(token: TOKEN)
+		end
+		describe 'API Functions' do
+			it 'get_users: it returns API call of users' do
+				api_call = @controller.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)
+			end
+			it 'create_user(payload: json): creates a user' do
+				user_name = "samanage-ruby-#{(rand*10**10).ceil}"
+				email = user_name + "@samanage.com"
+				json = {
+					:user => {
+						:name => user_name,
+						:email => email,
+					}
+				}
+				user_create = @controller.create_user(payload: json.to_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)
+				expect(user_create[:code]).to eq(200).or(201)
+			end
+			it 'create_user: fails if no email' do
+				user_name = "samanage-ruby-#{(rand*10**10).ceil}"
+				json = {
+					:user => {
+						:name => user_name,
+					}
+				}
+				expect{@controller.create_user(payload: json.to_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)
+				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{@controller.find_user(id: sample_id)}.to raise_error(Samanage::NotFound)  # id should match found user
+			end
+			it 'update_user: update_user by id' do
+				users = @controller.collect_users
+				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.to_json, id: sample_id)
+				expect(user_update[:data]["name"]).to eq(new_name)
+				expect(user_update[:code]).to eq(200).or(201)
+			end
+		end
+	end
+end

data/spec/samanage_api_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+describe Samanage do
+	describe 'API Controller' do
+		before(:each) do
+			TOKEN ||= ENV['SAMANAGE_TEST_API_TOKEN']
+		end
+	  context 'on creation' do
+	  	it 'Requires Email & Token' do
+	  		expect{ Samanage::Api.new() }.to raise_error(ArgumentError)
+	  		expect{ Samanage::Api.new(token: "invalid token") }.to raise_error(Samanage::AuthorizationError)
+	  		expect{ Samanage::Api.new(token: TOKEN) }.to_not raise_error
+	  	end
+
+	  	it 'Validates Credentials on Creation' do
+	  		# Valid Credentials
+	  		expect(Samanage::Api.new(token: TOKEN)).to be_an_instance_of(Samanage::Api)
+	  		# Invalid / Reversed Credentials
+				expect{Samanage::Api.new(token: 'invalid')}.to raise_error(Samanage::AuthorizationError)
+				expect(Samanage::Api.new(token: TOKEN).custom_forms).to be(nil)
+  		end
+
+  		it 'Finds all custom forms in development mode' do
+  			api_controller = Samanage::Api.new(token: TOKEN, development_mode: true)
+  			expect(api_controller).to be_an_instance_of(Samanage::Api)
+  			expect(api_controller.custom_forms).not_to be(nil)
+  			expect(api_controller.custom_forms).to be_a(Hash)
+  		end
+	  end
+	end
+end

data/spec/samanage_url_builder_spec.rb

@@ -0,0 +1,18 @@
+require 'samanage'
+describe Samanage::UrlBuilder do
+	context 'Url Builder' do
+		it 'Strips down to id' do
+			path = ['users.json','hardwares/1234']
+			options = [
+				{:id => '1234'},
+				{:id => 12345, :email => 'abc@company.com'},
+				{:email => 'abc', :name => 'Joe Doe'},
+				{:site => 0001, :id => 1234}
+			]
+			25.times {
+				url = Samanage::UrlBuilder.new(path: path.sample, options: options.sample).url
+				expect(url).to be_a(String)
+			}
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+spec_dir = File.expand_path(File.dirname(__FILE__))
+root_dir = File.expand_path(File.join(spec_dir, '..'))
+lib_dir = File.expand_path(File.join(root_dir, 'lib'))
+
+$LOAD_PATH.unshift(spec_dir)
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.uniq!
+
+require 'samanage'

data/test.rb

@@ -0,0 +1,4 @@
+require 'samanage'
+
+api_controller = Samanage::Api.new(token: 'SAMANAGE_TEST_API_TOKEN')
+puts api_controller

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: samanage
+version: !ruby/object:Gem::Version
+  version: '1.4'
+platform: ruby
+authors:
+- Chris Walls
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-01 00:00:00.000000000 Z
+dependencies: []
+description: Connect to Samanage using Ruby!
+email: chris.walls@samanage.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- lib/.DS_Store
+- lib/samanage.rb
+- lib/samanage/.DS_Store
+- lib/samanage/api.rb
+- lib/samanage/api/custom_fields.rb
+- lib/samanage/api/custom_forms.rb
+- lib/samanage/api/hardwares.rb
+- lib/samanage/api/incidents.rb
+- lib/samanage/api/other_assets.rb
+- lib/samanage/api/requester.rb
+- lib/samanage/api/users.rb
+- lib/samanage/error.rb
+- lib/samanage/url_builder.rb
+- lib/test.rb
+- samanage.gemspec
+- spec/api/samanage_custom_field_spec.rb
+- spec/api/samanage_custom_form_spec.rb
+- spec/api/samanage_hardware_spec.rb
+- spec/api/samanage_incident_spec.rb
+- spec/api/samanage_other_asset_spec.rb
+- spec/api/samanage_user_spec.rb
+- spec/samanage_api_spec.rb
+- spec/samanage_url_builder_spec.rb
+- spec/spec_helper.rb
+- test.rb
+homepage: http://rubygems.org/gems/samanage
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Samanage Ruby Gem
+test_files: []