smarteru 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 811c7b26440c9f22c4b5d41f6ec6a460e361d75d
-  data.tar.gz: 548cbb83653d4cee166a5ca60050b12fc4a065c6
+SHA256:
+  metadata.gz: 5b9a09b604285fcf6277b75b5844190f09994387214d03d2969e8db7dbe701ec
+  data.tar.gz: f1a43226645c1bd28eece5216bf7a45a43747016f9ca43c7a56081bd87f95f93
 SHA512:
-  metadata.gz: a5f2c67db38f87430695c4df2181f4661ddf56ee62dcb35263e44b466465377606058ce4974559730de273c3209b10cf349ed2e90208f971201aadbfa8fe29c1
-  data.tar.gz: 6581fb66f399816bf60e23a88696b3737c2d37122658c0ce18c04d9a47700365ea9e789a666f46d673766ffbe8980cef6e5d03de62eb22210bea9781d1beb42d
+  metadata.gz: a49703f950673e5c851aaddd7f4beb5a3aca23aa8597c4b78e7dcd3a9334be10b4166d0e2d4233263ccaabfd286e9df26a04d098c6865f76564d5dcbb7efbabf
+  data.tar.gz: 0406a8dcec0eaf5ddb0897483ed2e102b3ccb58286e490aeca046847473fda293d281995b79646c213d8d549d1f48f8c040d0f4bca4d07e4abe432a2d63a7782

data/Rakefile

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-require 'rubygems'
 require 'bundler'
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -9,7 +9,6 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-require 'rake'
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|

data/lib/smarteru.rb

@@ -1,9 +1,11 @@
 require 'rest-client'
-require 'libxml'
-require 'xmlhasher'
+require 'nori'
 
+require 'smarteru/error'
 require 'smarteru/client'
 require 'smarteru/response'
+require 'smarteru/resources/base'
+require 'smarteru/resources/users'
 
 module Smarteru
   API_HOST = 'api.smarteru.com'

data/lib/smarteru/client.rb

@@ -1,8 +1,7 @@
 module Smarteru
   class Client
-    attr_reader :account_api_key, :user_api_key,
-                :use_ssl, :verify_ssl, :ssl_ca_file,
-                :api_url
+    attr_accessor :account_api_key, :user_api_key
+    attr_reader :use_ssl, :verify_ssl, :ssl_ca_file, :api_url, :fail_on_error
 
     # Create an instance of an API client
     #
@@ -10,13 +9,14 @@ module Smarteru
     # * +options+ - Access credentials and options hash, required keys are: account_api_key, user_api_key
     # ==== Example
     # client = Smarteru::Client.new({account_api_key: 'abc', user_api_key: 'abc'})
-    def initialize options = {}
-      @account_api_key = options[:account_api_key]
-      @user_api_key = options[:user_api_key]
+    def initialize(options = {})
+      @account_api_key = options[:account_api_key] || ENV['SMARTERU_ACCOUNT_API_KEY']
+      @user_api_key = options[:user_api_key] || ENV['SMARTERU_USER_API_KEY']
       @use_ssl = options[:use_ssl] || true
       @verify_ssl = options[:verify_ssl]
       @ssl_ca_file = options[:ssl_ca_file]
-      @api_url = "#{use_ssl ? 'https' : 'http'}://#{API_HOST}/#{API_VERSION}/"
+      @api_url = (@use_ssl ? 'https' : 'http') + "://#{API_HOST}/#{API_VERSION}/"
+      @fail_on_error = options[:fail_on_error] != false
     end
 
     # Make an API request
@@ -32,14 +32,24 @@ module Smarteru
     # })
     def request(operation, data)
       opts = {
-        method: :post,
-        url: api_url,
-        payload: {'Package' => body(operation, data)},
+        method:       :post,
+        url:          api_url,
+        payload:      { 'Package' => body(operation, data) },
         content_type: :xml,
-        verify_ssl: verify_ssl,
-        ssl_ca_file: ssl_ca_file
-      }
-      Response.new(RestClient::Request.execute(opts))
+        verify_ssl:   verify_ssl,
+        ssl_ca_file:  ssl_ca_file }
+
+      response = RestClient::Request.execute(opts)
+      response = Response.new(response)
+
+      if !response.success? && fail_on_error
+        fail Error.new(response)
+      end
+      response
+    end
+
+    def users
+      @users ||= Resources::Users.new(self)
     end
 
     private
@@ -67,20 +77,23 @@ module Smarteru
     # * +parameters+ - Parameters hash
     def body_parameters(parameters)
       parameters_xml = ''
-      parameters.each_pair do |k,v|
+      parameters.each_pair do |k, v|
         key = parameter_key(k)
 
-        case v
+        val = case v
         when Hash
-          val = body_parameters(v)
+          body_parameters(v)
         when Array
-          val = v.map {|i| body_parameters(i) }.join('')
+          v.map { |i| body_parameters(i) }.join('')
+        when nil
+          ''
         else
-          val = "<![CDATA[#{v}]]>"
+          "<![CDATA[#{v}]]>"
         end
 
         parameters_xml << "<#{key}>#{val}</#{key}>"
       end
+
       parameters_xml
     end
 

data/lib/smarteru/error.rb

@@ -0,0 +1,12 @@
+module Smarteru
+  class Error < StandardError
+    attr_reader :response, :code
+
+    def initialize(response)
+      @response = response
+      @code = response.error[:error][:error_id]
+      super(response.error[:error][:error_message])
+    end
+
+  end
+end

data/lib/smarteru/resources/base.rb

@@ -0,0 +1,10 @@
+module Smarteru
+  module Resources
+    class Base
+      attr_reader :client
+      def initialize(client)
+        @client = client
+      end
+    end 
+  end
+end

data/lib/smarteru/resources/users.rb

@@ -0,0 +1,110 @@
+module Smarteru
+  module Resources
+    class Users < Base
+      def get(id_or_email)
+        params = { user: normalize_id_param(id_or_email) }
+
+        response = client.request('getUser', params)
+        response.success? ? response.result[:user] : response
+      rescue Error => e
+        return nil if e.code == 'GU:03'
+        fail e
+      end
+
+      def create(info = {})
+        validate!(info, :email, :employee_i_d, :given_name, :surname, :group)
+
+        params = create_params(info)
+
+        client.request('createUser', params)
+      end
+
+      def update(id_or_email, info = {})
+        params = { user:
+          { identifier: normalize_id_param(id_or_email),
+            info:       info,
+            profile:    nil,
+            groups:     nil } }
+
+        client.request('updateUser', params)
+      end
+
+      def update_employee_id(id_or_email, new_employee_id)
+        update(id_or_email, employee_i_d: new_employee_id)
+      end
+
+      def signin(id_or_email)
+        params = { security: normalize_id_param(id_or_email) }
+
+        client.request('requestExternalAuthorization', params)
+      end
+
+      def enroll(id_or_email, group, module_id)
+        params = {
+          learning_module_enrollment: {
+            enrollment: {
+              user:                normalize_id_param(id_or_email),
+              group_name:          group,
+              learning_module_i_d: module_id } } }
+
+        client.request('enrollLearningModules', params)
+      end
+
+      def learner_report(id_or_email, group)
+        params = {
+          report: {
+            filters: {
+              groups: {
+                group_names: {
+                  group_name: group } },
+              learning_modules: nil,
+              users: {
+                user_identifier: normalize_id_param(id_or_email, :email_address) } },
+            columns: [
+              { column_name: 'ENROLLED_DATE' },
+              { column_name: 'COMPLETED_DATE' },
+              { column_name: 'DUE_DATE' },
+              { column_name: 'LAST_ACCESSED_DATE' },
+              { column_name: 'STARTED_DATE' } ],
+            custom_fields: nil } }
+
+        response = client.request('getLearnerReport', params)
+        [ response.result[:learner_report][:learner] ].flatten.compact
+      end
+
+      def enrolled?(id_or_email, group, course_name)
+        enrollments = learner_report(id_or_email, group)
+        enrollments.any? { |e| e[:course_name] == course_name }
+      end
+
+      private
+
+      DEFAULT_CREATE_INFO = {
+          learner_notifications:    1,
+          supervisor_notifications: 0,
+          send_email_to:            'Self' }
+
+      def create_params(info)
+        group = info.delete(:group)
+
+        { user: {
+            info:    info.merge(DEFAULT_CREATE_INFO),
+            profile: { home_group: group },
+            groups: {
+              group: {
+                group_name:        group,
+                group_permissions: nil } } } }
+      end
+
+      def normalize_id_param(value, email_field_name = :email)
+        value =~ /@/ ? { email_field_name => value } : { employee_i_d: value }
+      end
+
+      def validate!(params, *args)
+        args.each do |arg|
+          fail(":#{arg} required to create user") unless params.include?(arg)
+        end
+      end
+    end
+  end
+end

data/lib/smarteru/response.rb

@@ -1,39 +1,39 @@
 module Smarteru
   class Response
-    attr_reader :data, :hash, :parser
+    attr_reader :data, :hash, :opts
 
     # Initializes an API response
     #
     # ==== Attributes
     # * +resp+ - RestClient response from the API
-    def initialize(res)
+    def initialize(res, opts = {})
       @data = res
-      @parser = XmlHasher::Parser.new(
-        snakecase: true,
-        ignore_namespaces: true,
-        string_keys: false
+      opts[:parser] ||= Nori.new(
+        parser:          :rexml,
+        convert_tags_to: lambda { |tag| tag.snakecase.to_sym }
       )
+      @opts = opts
     end
 
     # Hash representation of response data
-    def to_hash
-      return @hash if @hash
-      @hash = parser.parse(data.to_s.gsub(/\<!\[CDATA\[(.+)\]\]\>/) {$1})
+    def hash
+      @hash ||= opts[:parser].parse(data.to_s.gsub(/\<!\[CDATA\[([^\]]+)\]\]\>/) {$1})
     end
 
     # Return true/false based on the API response status
     def success?
-      to_hash[:smarter_u][:result] == 'Success'
+      hash[:smarter_u][:result] == 'Success'
     rescue
       false
     end
 
     def result
-      to_hash[:smarter_u][:info]
+      hash[:smarter_u][:info]
     end
 
     def error
-      to_hash[:smarter_u][:errors]
+      errors = hash[:smarter_u][:errors]
+      errors.is_a?(Hash) ? errors : nil
     end
   end
 end

data/lib/smarteru/version.rb

@@ -1,3 +1,3 @@
 module Smarteru
-  VERSION = '0.0.1'
+  VERSION = '0.0.4'
 end

data/test/smarteru_test.rb

@@ -1,45 +1,133 @@
-require 'helper'
+require 'test_helper'
 
 class TestSmarteru < Test::Unit::TestCase
-
   def setup
-    @client = Smarteru::Client.new(ACCESS_CREDENTIALS)
-  end
-
-  def test_request_get_group
-    stub_request = stub_v2_api_call('getGroup', request_payload('getGroup.xml'))
-    response = @client.request('getGroup', {group: {name: 'MyGroup'}})
-    assert_equal(response.data, expected_body('getGroup.xml'))
-    assert_requested(stub_request)
-  end
-
-  def test_response_result_hash
-    stub_request = stub_v2_api_call('getGroup', request_payload('getGroup.xml'))
-    response = @client.request('getGroup', {group: {name: 'MyGroup'}})
-    assert_equal(response.result, {
-      group: {
-        name: "MyGroup",
-        group_id: nil,
-        created_date: "2015-01-22 23:42:55.553",
-        modified_date: "2015-01-23 01:25:02.013",
-        description: {
-          p: "Group Description ..."
-        },
-        home_group_message: {
-          p: "Welcome to The Group"
-        },
-        notification_emails: nil,
-        user_count: "2",
-        learning_module_count: "2",
-        tags: nil,
-        status: "Active"
-      }
-    })
-  end
-
-  def test_response_success_method
-    stub_request = stub_v2_api_call('getGroup', request_payload('getGroup.xml'))
-    response = @client.request('getGroup', {group: {name: 'MyGroup'}})
-    assert_equal(true, response.success?)
+    @client = Smarteru::Client.new(
+      account_api_key: 'C3FE6BE08120A82DB9C4555A5C0E46AF',
+      user_api_key:    '*623jec3nad4!aic5rlg*$mrg8n4$itd^vy62xut')
+    # replace values w/ actual keys to run/test vcr cassettes
+    # @client = Smarteru::Client.new(
+    #   account_api_key: 'foo',
+    #   user_api_key:    'bar')
+  end
+
+  GROUP_PARAMS = { group: { name: 'PowurU' } }
+  def test_invalid_api_keys
+    @client.account_api_key = 'foo'
+    @client.user_api_key = 'bar'
+
+    VCR.use_cassette('invalid_api_keys') do
+      assert_raise_kind_of(Smarteru::Error) do
+        @client.request('getGroup', GROUP_PARAMS)
+      end
+    end
+  end
+
+  def test_get_group
+    with_request('get_group', 'getGroup', GROUP_PARAMS) do |response|
+      assert_true response.success?
+      assert_not_nil response.result[:group]
+    end
+  end
+
+  def test_get_user
+    email = 'vduplessie@gmail.com'
+
+    VCR.use_cassette('get_user') do
+      response = @client.users.get(email)
+      assert_not_nil response[:email] == email
+      assert_not_nil response[:status] == 'Active'
+    end
+  end
+
+  def test_get_nonexistant_user
+    VCR.use_cassette('get_nonexistant_user') do
+      response = @client.users.get('noop@eyecuelab.com')
+      assert_nil response
+    end
+  end
+
+  def test_update_user
+    VCR.use_cassette('update_user') do
+      employee_id = 'powur.com:4242'
+      response = @client.users.update('vduplessie@gmail.com', employee_i_d: employee_id)
+      assert_true response.success?
+      assert_true response.result.keys.include?(:employee_id)
+      assert_equal response.result[:employee_id], employee_id
+    end
+  end
+
+  def test_update_employee_id
+    VCR.use_cassette('update_employee_id') do
+      employee_id = 'powur.com:4242'
+      response = @client.users.update_employee_id('vduplessie@gmail.com', employee_id)
+      assert_true response.success?
+      assert_true response.result.keys.include?(:employee_id)
+      assert_equal response.result[:employee_id], employee_id
+    end
+  end
+
+  def test_create_user
+    employee_id = 'test.eyecuelab.com:42'
+    params = {
+      email:        'foo@eyecuelab.com',
+      employee_i_d: employee_id,
+      given_name:   'Test',
+      surname:      'User',
+      password:     'password',
+      group:        'PowurU' }
+
+    VCR.use_cassette('create_user') do
+      response = @client.users.create(params)
+      assert_true response.success?
+      assert_true response.result.keys.include?(:employee_id)
+      assert_equal response.result[:employee_id], employee_id
+    end
+  end
+
+  def test_signin_user
+    VCR.use_cassette('signin_user') do
+      response = @client.users.signin('5258029611')
+      assert_true response.success?
+      assert_true response.result.keys.include?(:redirect_path)
+    end
+  end
+
+  def test_enroll_user
+    VCR.use_cassette('enroll_user') do
+      response = @client.users.enroll('5258029611', 'PowurU', '8319')
+      assert_true response.success?
+      assert_true response.result.keys.include?(:enrollments)
+    end
+  end
+
+  def test_learner_report
+    VCR.use_cassette('learner_report') do
+      response = @client.users.learner_report('5258029611', 'PowurU')
+      assert_kind_of Array, response
+    end
+  end
+
+  def test_enrolled_true
+    VCR.use_cassette('enrolled_true') do
+      response = @client.users.enrolled?('foo@eyecuelab.com', 'PowurU', 'Fast Impact Training (FIT)')
+      assert_true response
+    end
+  end
+
+  def test_enrolled_false
+    VCR.use_cassette('enrolled_false') do
+      response = @client.users.enrolled?('foo@eyecuelab.com', 'PowurU', 'Cert Pro')
+      assert_false response
+    end
+  end
+
+  private
+
+  def with_request(cassette, method, params)
+    VCR.use_cassette(cassette) do
+      response = @client.request(method, params)
+      yield(response) if block_given?
+    end
   end
 end