user_management_api 0.0.16

data/spec/integration/registration_groups_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Registration Groups', integration: true do
+
+  before(:each) do
+    users = client.users_by_email(['owner@tet.com', 'enrolled1@tet.com', 'enrolled2@tet.com'])
+    @owner = users.detect { |u| u.email == 'owner@tet.com' }
+    @enrolled1 = users.detect { |u| u.email == 'enrolled1@tet.com' }
+    @enrolled2 = users.detect { |u| u.email == 'enrolled2@tet.com' }
+  end
+
+  it 'returns data for group owners' do
+    data = client.owned_registration_groups('cps', @owner.unique_id)
+    expect(data.length).to eq 1
+    expect(data.first).to be_a UserManagementApi::RegistrationGroup
+    expect(data.first.owner.unique_id).to eq @owner.unique_id
+  end
+
+  it 'returns data for group enrollees' do
+    data = client.enrolled_registration_groups('cps', @enrolled1.unique_id)
+    expect(data.length).to eq 1
+    expect(data.first).to be_a UserManagementApi::RegistrationGroup
+  end
+
+  it 'returns data for pending groups' do
+    data = client.pending_registration_groups('cps')
+    expect(data.length).to eq 3
+    expect(data.first).to be_a UserManagementApi::RegistrationGroup
+  end
+end

data/spec/integration/registrations_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Registrations', integration: true do
+
+  describe 'search' do
+
+    it 'returns a page of data given no criteria' do
+      data = client.search_registrations('usa')
+      expect(data.length).to eq 25
+      expect(data.current_page).to eq 1
+      expect(data.first).to be_a UserManagementApi::Registration
+    end
+
+    it 'returns a page of data given a page size' do
+      data = client.search_registrations('usa', per: 20)
+      expect(data.length).to eq 20
+      expect(data.total_pages).to eq 2
+      expect(data.first).to be_a UserManagementApi::Registration
+    end
+
+  end
+
+  describe 'set_registration_custom_attributes' do
+
+    before(:each) do
+      @user = client.users_by_email('owner@tet.com').first
+    end
+
+    it 'correctly updates custom attributes' do
+      reg = client.user_registration('cps', @user.unique_id)
+      expect(reg.custom_attributes).to eq({})
+
+      reg = client.set_registration_custom_attributes('cps', @user.unique_id, {key1: 'value1', key2: 'value2'})
+
+      expect(reg.custom_attributes).to eq({'key1' => 'value1', 'key2' => 'value2'})
+
+      reg = client.set_registration_custom_attributes('cps', @user.unique_id, {key1: 'value1-updated', key2: ''})
+
+      expect(reg.custom_attributes).to eq({'key1' => 'value1-updated'})
+    end
+
+  end
+
+end

data/spec/integration/users_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Users', integration: true do
+
+  describe 'User Retrieval' do
+
+    before(:each) do
+      @user = client.create_user(UserManagementApi::User.new({email: "#{SecureRandom.uuid}@example.com", first_name: 'Eddie', last_name: 'Dean', password: '1nine9teen'}))
+    end
+
+    it 'should retrieve a user' do
+      user = client.user(@user.unique_id)
+      expect(user).not_to be_nil
+      expect(user.unique_id).to eq @user.unique_id
+      expect(user.email).to eq @user.email
+    end
+
+    it 'should return nil for an invalid id' do
+      user = client.user('abc123')
+      expect(user).to be_nil
+    end
+
+  end
+
+  describe 'User Creation' do
+    it 'should create and return a user' do
+      user = client.create_user(UserManagementApi::User.new({email: "#{SecureRandom.uuid}@example.com", first_name: 'Eddie', last_name: 'Dean', password: '1nine9teen'}))
+      found = client.user(user.unique_id)
+      expect(found).not_to be_nil
+      expect(found.email).to eq user.email
+    end
+
+    it 'should raise UnprocessableEntityError with an invalid user' do
+      expect { client.create_user(UserManagementApi::User.new({email: "#{SecureRandom.uuid}@example.com"})) }.to raise_error(UserManagementApi::UnprocessableEntityError) do |error|
+        expect(error.errors).not_to be_nil
+        expect(error.errors['first_name']).not_to be_nil
+      end
+    end
+  end
+
+  describe 'User Updates' do
+
+    before(:each) do
+      @user = client.create_user(UserManagementApi::User.new({email: "#{SecureRandom.uuid}@example.com", first_name: 'Eddie', last_name: 'Dean', password: '1nine9teen'}))
+    end
+
+    it 'should update and return a user' do
+      @user.first_name = 'Edward'
+      u = client.update_user(@user)
+      expect(u.last_name).to eq 'Dean'
+      expect(u.first_name).to eq 'Edward'
+    end
+
+    it 'should raise UnprocessableEntityError with an invalid user' do
+      @user.first_name = nil
+      expect { client.update_user(@user) }.to raise_error(UserManagementApi::UnprocessableEntityError) do |error|
+        expect(error.errors).not_to be_nil
+        expect(error.errors['first_name']).not_to be_nil
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'oj'
+require 'simplecov'
+require 'simplecov-rcov'
+
+MultiJson.use :oj
+
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/vendor/bundle'
+end
+
+require 'rspec'
+require 'webmock/rspec'
+require File.expand_path('../../lib/user_management_api', __FILE__)
+
+Dir[File.expand_path('../support/**/*', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+
+  config.add_setting :uma_port, default: ENV['UMA_PORT'] || 3000
+
+  config.filter_run_excluding :integration unless ENV['ENABLE_INTEGRATION'] == 'true'
+end

data/spec/support/client_context.rb

@@ -0,0 +1,12 @@
+
+RSpec.shared_context "client context" do
+  let(:uri) { 'http://example.com' }
+  let(:token) { 'token' }
+  let(:client) { UserManagementApi::Client.new(uri, token) }
+  let(:base_uri) { client.base_api_uri }
+
+  let(:day) { 60 * 60 * 24 }
+
+  let(:unique_id) { SecureRandom.uuid }
+  let(:user_json) { { unique_id: "#{unique_id}", email: "roland@tet.com", first_name: "Roland", last_name: "Deschain" } }
+end

data/spec/support/integration_context.rb

@@ -0,0 +1,29 @@
+
+RSpec.shared_context("integration context", { integration: true }) do
+
+  # Disable WebMocks and make requests to the real deal
+  before(:all) do
+    WebMock.disable!
+  end
+
+  after(:all) do
+    WebMock.enable!
+  end
+
+  before(:each) do
+    # Assume there's a UserManagementApp running in the integration_test env on localhost
+    uri = "http://localhost:#{RSpec.configuration.uma_port}"
+
+    # Reseed the UMA app
+    Faraday.get("#{uri}/integration_test/reseed")
+
+    # Magic test token.  See UserManagementApp/lib/integration_test_seeder.rb
+    token = '00000000-1111-2222-3333-444444444444'
+    @client = UserManagementApi::Client.new(uri, token)
+  end
+
+  def client
+    @client
+  end
+
+end

data/spec/unit/client_methods/answerbase_session_tokens_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe UserManagementApi::ClientMethods::AnswerbaseSessionTokens do
+
+  include_context 'client context'
+
+  let(:session_id) { SecureRandom::uuid }
+  let(:token_json) { {user_unique_id: unique_id, session_id: session_id, created_at: Time.now, updated_at: Time.now} }
+
+  describe '#answerbase_session_token' do
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, "#{base_uri}/answerbase_session_tokens/#{session_id}")
+      client.answerbase_session_token(session_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns nil when an invalid id is passed' do
+      stub = stub_request(:get, "#{base_uri}/answerbase_session_tokens/#{session_id}").to_return(:status => 404)
+
+      expect(client.answerbase_session_token(session_id)).to be_nil
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns a AnswerbaseSessionToken object' do
+      stub = stub_request(:get, "#{base_uri}/answerbase_session_tokens/#{session_id}").to_return(body: MultiJson.dump(token_json))
+
+      token = client.answerbase_session_token(session_id)
+
+      expect(token).not_to be_nil
+      expect(token).to be_a(UserManagementApi::AnswerbaseSessionToken)
+      expect(token.session_id).to eq session_id
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#create_answerbase_session_token' do
+    it 'makes a POST to the correct url' do
+      stub = stub_request(:post, "#{base_uri}/answerbase_session_tokens/#{unique_id}")
+      client.create_answerbase_session_token(unique_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'raises a UnprocessableEntityError on a 422' do
+      stub = stub_request(:post, "#{base_uri}/answerbase_session_tokens/junk").to_return(status: 422, body: MultiJson.dump({session_id: ['Cannot be blank']}))
+
+      expect { client.create_answerbase_session_token('junk') }.to raise_error(UserManagementApi::UnprocessableEntityError)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns a AnswerbaseSessionToken object' do
+      stub = stub_request(:post, "#{base_uri}/answerbase_session_tokens/#{unique_id}").to_return(body: MultiJson.dump(token_json))
+
+      token = client.create_answerbase_session_token(unique_id)
+
+      expect(token).not_to be_nil
+      expect(token).to be_a(UserManagementApi::AnswerbaseSessionToken)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+end

data/spec/unit/client_methods/registration_groups_spec.rb

@@ -0,0 +1,157 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe UserManagementApi::ClientMethods::RegistrationGroups do
+
+  include_context 'client context'
+
+  let(:registration_group_json) { { unique_id: SecureRandom.uuid, name: 'Group', project: 'cps', end_date: Time.now + day, active: true, created_at: Time.now, updated_at: Time.now, owner: user_json } }
+
+  describe '#owned_registration_groups' do
+    let(:url) { "#{base_uri}/registration_groups/cps/owned/#{unique_id}" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.owned_registration_groups('cps', unique_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns an array of RegistrationGroups' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump([registration_group_json, registration_group_json]))
+
+      groups = client.owned_registration_groups('cps', unique_id)
+
+      expect(groups).to be_a Array
+      expect(groups.length).to eq 2
+      expect(groups.first).to be_a UserManagementApi::RegistrationGroup
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#enrolled_registration_groups' do
+    let(:url) { "#{base_uri}/registration_groups/cps/enrolled/#{unique_id}" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.enrolled_registration_groups('cps', unique_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns an array of RegistrationGroups' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump([registration_group_json, registration_group_json]))
+
+      groups = client.enrolled_registration_groups('cps', unique_id)
+
+      expect(groups).to be_a Array
+      expect(groups.length).to eq 2
+      expect(groups.first).to be_a UserManagementApi::RegistrationGroup
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#registration_group' do
+
+    let(:registration_group_uid) { SecureRandom.uuid }
+    let(:url) { "#{base_uri}/registration_groups/#{registration_group_uid}" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.registration_group(registration_group_uid)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns a RegistrationGroup object' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump(registration_group_json))
+
+      rg = client.registration_group(registration_group_uid)
+
+      expect(rg).to be_a UserManagementApi::RegistrationGroup
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#registration_group_enrollees' do
+
+    let(:registration_group_uid) { SecureRandom.uuid }
+    let(:url) { "#{base_uri}/registration_groups/#{registration_group_uid}/enrollees" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.registration_group_enrollees(registration_group_uid)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns an array of Users' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump([user_json, user_json]))
+
+      rg = client.registration_group_enrollees(registration_group_uid)
+
+      expect(rg).to be_a Array
+      expect(rg.first).to be_a UserManagementApi::User
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#registration_group_remove_enrollee' do
+
+    let(:registration_group_uid) { SecureRandom.uuid }
+    let(:url) { "#{base_uri}/registration_groups/#{registration_group_uid}/enrollees/#{unique_id}" }
+
+    it 'makes a DELETE request to the correct URL' do
+      stub = stub_request(:delete, url)
+      client.registration_group_remove_enrollee(registration_group_uid, unique_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns true for a 200 response' do
+      stub = stub_request(:delete, url).to_return(body: MultiJson.dump({notice: 'good'}))
+
+      rg = client.registration_group_remove_enrollee(registration_group_uid, unique_id)
+
+      expect(rg).to eq true
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns false for a 404 response' do
+      stub = stub_request(:delete, url).to_return(body: MultiJson.dump({error: 'not found'}), status: 404)
+
+      rg = client.registration_group_remove_enrollee(registration_group_uid, unique_id)
+
+      expect(rg).to eq false
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#pending_registration_groups' do
+    let(:url) { "#{base_uri}/registration_groups/cps/pending" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.pending_registration_groups('cps')
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns an array of RegistrationGroups' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump([registration_group_json, registration_group_json]))
+
+      groups = client.pending_registration_groups('cps')
+
+      expect(groups).to be_a Array
+      expect(groups.length).to eq 2
+      expect(groups.first).to be_a UserManagementApi::RegistrationGroup
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+end

data/spec/unit/client_methods/registrations_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe UserManagementApi::ClientMethods::RegistrationGroups do
+
+  include_context 'client context'
+
+  let(:registration_json) { {user_unique_id: unique_id, institution: 'Tet', project: 'cps', max_extract_size: 20480, field: {id: 1, label: 'label'}, research_areas: [{id: 1, label: 'research'}, {id: 2, label: 'science'}]} }
+  let(:registration_list) { [registration_json, registration_json, registration_json] }
+  let(:paged_registration_list) { { total_count: 3, total_pages: 1, current_page: 1, registrations: registration_list } }
+
+  describe '#user_registrations' do
+
+    let(:url) { "#{base_uri}/registrations/#{unique_id}" }
+
+    it 'makes a GET to the correct url' do
+      stub = stub_request(:get, url)
+      client.user_registrations(unique_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns nil for an invalid user' do
+      stub = stub_request(:get, url).to_return(:status => 404)
+
+      expect(client.user_registrations(unique_id)).to be_nil
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns an array of projects for a valid user' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump(registration_list))
+
+      list = client.user_registrations(unique_id)
+
+      expect(list).not_to be_nil
+      expect(list).to be_a(Array)
+      expect(list.size).to eq 3
+      expect(list.first).to be_a(UserManagementApi::Registration)
+      expect(list.first.institution).to eq 'Tet'
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#user_registration' do
+
+    let(:url) { "#{base_uri}/registrations/cps/#{unique_id}" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.user_registration('cps', unique_id)
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns nil when an invalid id is passed' do
+      stub = stub_request(:get, url).to_return(:status => 404)
+
+      expect(client.user_registration('cps', unique_id)).to be_nil
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns a Registration object' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump(registration_json))
+
+      reg = client.user_registration('cps', unique_id)
+
+      expect(reg).not_to be_nil
+      expect(reg).to be_a(UserManagementApi::Registration)
+      expect(reg.institution).to eq 'Tet'
+      expect(reg.field).not_to be_nil
+      expect(reg.field.id).to eq 1
+      expect(reg.max_extract_size).to eq 20480
+
+      expect(reg.research_areas).not_to be_nil
+      expect(reg.research_areas).to be_a(Array)
+      expect(reg.research_areas.first.id).to eq 1
+
+      expect(stub).to have_been_requested.times(1)
+    end
+  end
+
+  describe '#search_registrations' do
+
+    let(:url) { "#{base_uri}/registrations/cps" }
+
+    it 'makes a GET request to the correct URL' do
+      stub = stub_request(:get, url)
+      client.search_registrations('cps')
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns a PagedCollection object' do
+      stub = stub_request(:get, url).to_return(body: MultiJson.dump(paged_registration_list))
+
+      data = client.search_registrations('cps')
+
+      expect(data).to be_a UserManagementApi::PagedCollection
+      expect(data.total_pages).to eq 1
+      expect(data.total_count).to eq 3
+      expect(data.current_page).to eq 1
+      expect(data.length).to eq 3
+      expect(data.first).to be_a UserManagementApi::Registration
+      expect(data.first.institution).to eq 'Tet'
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+  end
+
+  describe '#set_registration_custom_attributes' do
+    let(:url) { "#{base_uri}/registrations/cps/#{unique_id}/custom_attributes" }
+
+    it 'makes a PATCH request to the correct URL' do
+      stub = stub_request(:patch, url)
+      client.set_registration_custom_attributes('cps', unique_id, {key: 'value'})
+
+      expect(stub).to have_been_requested.times(1)
+    end
+
+    it 'returns a Registration object' do
+      stub = stub_request(:patch, url).to_return(body: MultiJson.dump(registration_json))
+      data = client.set_registration_custom_attributes('cps', unique_id, {key: 'value'})
+
+      expect(data).to be_a UserManagementApi::Registration
+    end
+  end
+
+end