kgrift 1.3.108

data/KGrift/knewton_grifts/helper_grifts.rb

@@ -0,0 +1,92 @@
+require 'securerandom'
+require 'time'
+#magic date math methods come from active support
+require 'active_support/core_ext/date/calculations'
+require 'active_support/core_ext/numeric/time'
+require 'digest'
+
+module ::TestDataHelpers
+def random_uuid
+  SecureRandom.uuid
+end
+
+def uuid_to_bit_string uuid
+  #remove dashes
+  #convert into hex, and back into a base 2 number/string
+  #pad the left with 0s
+  uuid.gsub('-','').to_i(16).to_s(2).rjust(128, '0')
+end
+
+def is_test_uuid? uuid
+  #the 41st bit is the test bit
+  uuid_to_bit_string(uuid)[40] == '1'
+end
+
+def random_string length=32
+  # to get the right length, for both both even and odd lengths,
+  # we have to pull a couple little tricks given that
+  # SecureRandom.hex returns twice the length requested
+  # SecureRandom.hex though is the best way I've found to get
+  # good random printable strings with a basic character set
+  s = SecureRandom.hex((length/2) + 1).to_s # add one so get a bit more than we need
+  s = s.force_encoding 'utf-8'
+  s[0...length]  #chop the string to the length needed
+end
+
+# uses chinese characters
+ChineseChars = [*"\u4E00".."\u9FFF"]
+def random_chinese_string length=32
+  length.times.map{ ChineseChars.sample }.join('')
+end
+
+def timestamp_string
+  Time.now.strftime('%m%d%y%H%M%S')
+end
+
+def random_graph_name
+  "TestGraph_#{random_string}"
+end
+
+def random_taxonomy_name
+  "TestTaxonomy_#{random_string}"
+end
+
+def random_learning_instance_name
+  "TestLearningInstance_#{random_string}"
+end
+
+def datetime_now
+  #rfc-3339 format 2013-03-13T16:06:06-04:00
+  #which is same as iso8601 (except in the very limited case of 00 timezones)
+  #http://en.wikipedia.org/wiki/ISO_8601#Usage
+  Time.now.utc.round.iso8601(3)
+end
+alias :datetime :datetime_now
+
+def days_from_now num_days
+  #for cleanliness days timestamps are all at midnight
+  num_days.to_i.days.from_now.utc.beginning_of_day.round.iso8601(3)
+end
+
+def bad_json_payloads
+  ["", "boomdeyada"]
+end
+
+def get_file_sha1 path
+  Digest::SHA1.hexdigest(File.read(path))
+end
+
+def get_mref_eid label
+  "mref-#{label}-#{random_string(20)}"
+end
+
+def get_gref_eid label
+  "gref-#{label}-#{random_string(20)}"
+end
+
+def get_tref_eid label
+  "tref-#{label}-#{random_string(20)}"
+end
+
+end
+include ::TestDataHelpers

data/KGrift/knewton_grifts/jmeter_data_grifts.rb

@@ -0,0 +1,56 @@
+
+
+def csv_to_hash csv_filename
+  CSV.read(csv_filename, headers: true).map {|a| Hash[a] }
+end
+
+def csv_data_set filename, &blk
+  if not File.exist? filename
+    data = yield blk
+    columns = data.first.keys
+
+    csv = CSV.generate do |csv|
+      csv << columns
+      data.each do |row|
+        csv << row.values
+      end
+    end
+    File.open(filename, 'w') {|f| f.write csv}
+  end
+
+  csv_to_hash filename
+end
+
+
+# returns a flat hash that can be written right into a csv
+def jmeter_partner
+
+  partner = create_partner_with_admin
+
+  flat_data = {
+    'partner_id' => partner['partner_id'],
+    'client_id' => partner['client_credentials']['client_id'],
+    'client_secret' => partner['client_credentials']['client_secret'],
+    'system_user_1' => partner['external_user_id'],
+  }
+
+  as_account :knerd do
+    set_partner_rate_limit_multiplier partner['partner_id'], 1000.0
+  end
+
+  flat_data['basic_auth_header'] = 'Basic ' + Base64.strict_encode64(
+    flat_data['client_id'] + ':' + flat_data['client_secret'])
+
+  tokens = get_access_token 'code' => nil,
+    'redirect_uri' => nil,
+    'scope' => flat_data['system_user_1'],
+    'grant_type' => "client_credentials",
+    'client_credentials' => partner['client_credentials'],
+    'external_user_id' => flat_data['system_user_1']
+
+  # the access token isnt really useful, just the refresh token
+  # flat_data['access_token'] = tokens['access_token']
+  flat_data['refresh_token'] = tokens['refresh_token']
+
+  flat_data
+end

data/KGrift/knewton_grifts/learning_instance_grifts.rb

@@ -0,0 +1,46 @@
+def get_learning_instances params={}
+  Log.info "Getting all learning instances, with params '#{params.keys.join(', ')}'"
+  kapi.get '/v0/learning-instances?' + URI.encode_www_form(params)
+end
+
+def create_learning_instance overrides={}
+  Log.info "Creating a learning instance"
+  kapi.post '/v0/learning-instances', {
+    'name' => random_learning_instance_name,
+    'graph_id' => '123'
+  }.merge(overrides)
+end
+
+# Get a learning instance.
+# If you also want to the partner_id of the learning instance,
+# then send this for get_opts: additional_headers: { 'X-Include-Partner-Id' => 'true' }
+# You can then access the partner_id with: kapi.last_response['X-Partner-Id']
+def get_learning_instance id, get_opts={}
+  Log.info "Getting a learning instance: " + id
+  kapi.get "/v0/learning-instances/#{id}", get_opts
+end
+
+def update_learning_instance id, overrides
+  Log.info "Updating a learning instance: " + id
+  kapi.put "/v0/learning-instances/#{id}", {
+    #'name' => 'updated name',
+  }.merge(overrides)
+end
+
+def delete_learning_instance id
+  Log.info "Deleting a learning instance: " + id
+  kapi.delete "/v0/learning-instances/#{id}"
+end
+
+def get_learning_instance_registrations id, params={}
+  Log.info "Getting registrations for learning instance, with params '#{params.keys.join(', ')}'"
+  kapi.get "/v0/learning-instances/#{id}/registrations?" + URI.encode_www_form(params)
+end
+
+# get a group recommendation (vox)
+def get_group_recommendation learning_instance_id, goal_id
+  Log.info "Getting a recommendation for learning instance: " + learning_instance_id + " goal: " + goal_id
+  query_params= { 'goal_id' => goal_id }
+  query_string = URI.encode_www_form(query_params)
+  kapi.get "/v0/learning-instances/#{learning_instance_id}/recommendation?#{query_string}"
+end

data/KGrift/knewton_grifts/looper_grifts.rb

@@ -0,0 +1,34 @@
+# Bivins has some special looper only endpoints at /0/looper/_/
+#
+# These grifts can be used to test those endpoints
+
+
+# looper_update_partner_display_name is the only supported way to
+# update the display_name of a partner.  PUT /v0/partners/:id does not work for display_name field
+#
+def looper_update_partner_display_name partner_id, new_display_name
+  kapi.put "/v0/looper/_/partners/#{partner_id}", {
+    'display_name' => new_display_name,
+  }
+end
+
+def looper_get_graph_internal_id partner_id, graph_external_id
+  kapi.get "/v0/looper/_/graph_uuid_from_partner/#{partner_id}/label/#{URI.encode_www_form_component(graph_external_id)}"
+end
+
+def looper_get_graph_module_internal_id graph_id, module_external_id
+  kapi.get("/v0/looper/_/module_uuid_from_graph/#{graph_id}/label/#{URI.encode_www_form_component(module_external_id)}")
+end
+
+def looper_get_graph_learning_objective_internal_id graph_id, learning_objective_eid
+  kapi.get("/v0/looper/_/learning_objective_uuid_from_graph/#{graph_id}/label/#{URI.encode_www_form_component(learning_objective_eid)}")
+end
+
+def looper_get_graph_taxon_internal_id partner_id, taxon_eid, graph_id
+  kapi.get("/v0/looper/_/taxon_uuid_from_partner/#{partner_id}/label/#{URI.encode_www_form_component(taxon_eid)}/graph/#{graph_id}")
+end
+
+def looper_get_indexed_graph graph_id
+  kapi.get("/v0/looper/_/indexed_graphs/#{graph_id}")
+end
+

data/KGrift/knewton_grifts/moxy_grifts.rb

@@ -0,0 +1,64 @@
+## Grifts to make requests against the Moxy endpoints for partner load testing
+##    with randomized responses.
+
+def moxy_send_ungraded_event registration_id, module_id, overrides={}
+  Log.info "Sending a moxy ungraded event"
+  kapi.post "/v0/moxy/registrations/#{registration_id}/ungraded-events", {
+    'duration' =>             876543,
+    'module_id' =>            module_id,
+    'is_complete' =>          true,
+    'interaction_end_time' => datetime,
+  }.merge(overrides)
+end
+
+def moxy_send_graded_event registration_id, module_id, overrides={}
+  Log.info "Sending a moxy graded event"
+  kapi.post "/v0/moxy/registrations/#{registration_id}/graded-events", {
+    'response' =>             "sample of a response",
+    'duration' =>             4321,
+    'module_id' =>              module_id,
+    'interaction_end_time' => datetime,
+    'score' =>                0.99,
+    'is_correct' =>           true,
+    'is_complete' =>          true,
+  }.merge(overrides)
+end
+
+def moxy_send_batch_events registration_id, events, overrides={}
+  Log.info "Sending a moxy batch of focus events"
+  kapi.post "/v0/moxy/registrations/#{registration_id}/batch-events", {
+    'goal_id' => nil,
+    'events' => events
+  }.merge(overrides)
+end
+
+def moxy_send_focus_event registration_id, goal_id, overrides={}
+  Log.info "Sending a moxy focus event"
+  kapi.post "/v0/moxy/registrations/#{registration_id}/focus-events", {
+    'goal_id' => goal_id,
+  }.merge(overrides)
+end
+
+def moxy_get_recommendation registration_id, goal_id=nil, continued_recommendations=nil
+  goal_id = random_uuid unless goal_id  #this only works in local mode, considering removing it
+  Log.info "Getting a moxy recommendation for registration: " + registration_id + " goal: " + goal_id
+  query_params= { 'goal_id' => goal_id }
+  query_params['continued_recommendations'] = continued_recommendations if continued_recommendations
+  query_string = URI.encode_www_form(query_params)
+  kapi.get "/v0/moxy/registrations/#{registration_id}/recommendation?#{query_string}"
+end
+
+def moxy_get_registration_metrics registration_id, metric_name, options
+  Log.info "Getting moxy analytics for registration: " + registration_id + " metric: " + metric_name
+  kapi.get "/v0/moxy/registrations/#{registration_id}/metrics/#{metric_name}" + '?' + options.join('&')
+end
+
+def moxy_get_learning_instance_metrics learning_instance_id, metric_name, request_body={}
+  Log.info "Getting moxy analytics for learning instance: " + learning_instance_id + " metric: " + metric_name
+  kapi.post "/v0/moxy/learning-instances/#{learning_instance_id}/metrics/#{metric_name}/rows", request_body
+end
+
+def moxy_get_learning_instance_group_metrics learning_instance_id, request_body={}
+  Log.info "Getting moxy groups analytics for learning instance: " + learning_instance_id
+  kapi.post "/v0/moxy/learning-instances/#{learning_instance_id}/metrics/groups", request_body
+end

data/KGrift/knewton_grifts/oauth_grifts.rb

@@ -0,0 +1,182 @@
+def knerd_token
+  #this is a handy helper for other apps to quickly get a bearer token
+  #run it like:  grift -e qa -q -n knerd_token
+  set_account :knerd
+  kapi.headers['Authorization']
+end
+
+def authenticate profile
+  #if !profile.has_key?('username')
+  #  profile.merge!('username'=>random_string)
+  #end
+  #if !profile.has_key?('password')
+  #  profile.merge!('password'=>random_string)
+  #end
+
+  code = get_authorization_grant(profile)['code']
+  token = get_access_token(
+    'code' => code,
+    'client_credentials' => profile.select{|k| k=='client_id' or k=='client_secret'},
+    'external_user_id' => profile['external_user_id'],
+  )['access_token']
+  set_authorization_headers token
+end
+
+def get_authorization_grant parameters={}
+  Log.info "Authenticating as user '#{parameters['username']}'"
+  parameters = {
+      'response_type' => "code",
+      'client_id' => nil,
+      'redirect_uri' => "http://client-redirect-uri",
+  }.merge(parameters).delete_if{|k,v| v.nil?}
+  kapi.post_form "/v0/oauth/authorize", parameters
+end
+
+def get_access_token options
+  raise ArgumentError.new("options must be a Hash") unless options.is_a? Hash
+  auth_header = construct_basic_auth_header_overrides options.delete 'client_credentials'
+  Log.info "Getting an access token"
+  params = {
+    'code' => options['code'],
+    'grant_type' => "authorization_code",
+    'redirect_uri' => "http://client-redirect-uri",
+    'external_user_id' => random_string,
+  }.merge(options).delete_if{|k,v| v.nil?}
+  kapi.post_form '/v0/oauth/token', params, additional_headers: auth_header
+end
+
+def get_access_token_from_refresh_token options
+  raise ArgumentError.new("options must be a Hash") unless options.is_a? Hash
+  auth_header = construct_basic_auth_header_overrides options.delete 'client_credentials'
+  Log.info "Getting an access token from a refresh token"
+  params = {
+    'refresh_token' => options['refresh_token'],
+    'grant_type' => "refresh_token",
+    'redirect_uri' => "http://client-redirect-uri",
+    'external_user_id' => random_string,
+  }.merge(options)
+  kapi.post_form '/v0/oauth/token', params, additional_headers: auth_header
+end
+
+def unauthenticate
+  set_authorization_headers nil
+end
+
+def get_current_account
+  kapi.get '/v0/accounts/current'
+end
+
+def get_account_by_id account_id
+  kapi.get "/v0/accounts/#{account_id}", additional_headers: { 'X-Include-Partner-Id' => 'true' }
+end
+
+def get_account_by_username partner_id, username
+  kapi.get "/v0/accounts/?partner_id=#{partner_id}&username=#{username}"
+end
+
+def get_account_id_for external_user_id, client_credentials=nil
+  as_account external_user_id, client_credentials do
+    get_current_account['id']
+  end
+end
+
+def update_account account_id, overrides={}
+  kapi.put "/v0/accounts/#{account_id}", {}.merge(overrides)
+end
+
+def create_account overrides={}
+  kapi.post "/v0/accounts", {
+    'external_user_id' => random_string,
+    'entitlements' => []
+  }.merge(overrides)
+end
+
+def delete_account account_id
+  response = kapi.delete "/v0/accounts/#{account_id}"
+  # a deleted account shouldn't have access to the api
+  # so any tokens we have cached are no good
+  # throwing them away is important to ensure certain integration tests work correctly
+  delete_account_id_from_token_cache account_id
+  response
+end
+
+def create_account_with_username_password_for_partner username, password, partner_id, overrides={}
+  kapi.post "/v0/looper/_/accounts/", {
+    'partner_id' => partner_id,
+    'username' => username,
+    'password' => password,
+    'external_user_id' => random_string,
+    'entitlements' => []
+  }.merge(overrides)
+end
+
+def make_account_partner_admin account_id
+  update_account account_id, 'entitlements' => ['all']
+end
+
+def update_looper_account_entitlements_by_username looper_partner_id, username, entitled_partner_ids
+  as_account :knerd do
+    account_response = get_account_by_username looper_partner_id, username
+    update_looper_account_entitlements account_response['id'], entitled_partner_ids
+  end
+end
+
+def update_looper_account_entitlements account_id, entitled_partner_ids
+  kapi.put "/v0/accounts/#{account_id}", {
+    'id' => account_id,
+    'entitlements' => ['partner_admin'],
+    'entitlements_metadata' => { 'partner_admin' => entitled_partner_ids.map { |id| { 'partner_id' => id } } }
+  }
+end
+
+
+# This is a list of services that is not authenticated using knewton oauth
+# graphtools is authenticated using google oauth2
+# see graphtools_authenticate in graphtools_grifts
+NON_AUTH_SERVICES=[:graphtools]
+
+def set_authorization_headers token
+  if token
+    formatted_token = case token.to_sym
+                    when /^\S+$/  #no spaces
+                      'Bearer ' + token
+                    else
+                      token
+                    end
+  end
+  svcs = grifter_configuration[:services].keys
+  svcs.each do |svc|
+    #  do not set the header for the special services authenticated in other ways
+    next if NON_AUTH_SERVICES.include? svc
+    if formatted_token
+      self.send(svc).headers['Authorization'] = formatted_token
+    else
+      self.send(svc).headers.delete 'Authorization'
+    end
+  end
+  formatted_token  #return the actual token, I guess
+end
+
+#this helper is used for adding the basic http auth parameter where needed in a standardized way
+#it can be given either client_credentials or client_id/client_secret separately
+require 'base64'
+def construct_basic_auth_header_overrides options={}
+  options={} unless options!=nil
+  #client credentials given
+  client_id=nil
+  client_secret=nil
+  if options.has_key? 'client_credentials'
+    client_id = options['client_credentials']['client_id']
+    client_secret = options['client_credentials']['client_secret']
+  #client id and secret given separately
+  elsif options.has_key? 'client_id' and options.has_key? 'client_secret'
+    client_id = options['client_id']
+    client_secret = options['client_secret']
+  #no sufficient information (use default partner)
+  else
+    client_id = get_client_id
+    client_secret = get_client_secret
+  end
+  encoded_token = Base64.strict_encode64(client_id + ':' + client_secret)
+  {'Authorization' => 'Basic ' + encoded_token}
+end