kgrift 1.3.108

data/KGrift/knewton_grifts/partner_grifts.rb

@@ -0,0 +1,70 @@
+#NOTICE: this only lists test partners, which does not include the Knewton partner
+def list_partners overrides={}
+  params = {
+    "test_partners" => true
+  }.merge(overrides).delete_if{|k,v| v.nil?}
+
+  Log.info "Listing all partners"
+  kapi.get '/v0/partners?' + URI.encode_www_form(params), timeout: 3600
+end
+
+def list_prod_partners overrides={}
+  params = {
+    'test_partners' => false,
+  }.merge(overrides)
+  list_partners params
+end
+
+def create_partner overrides={}
+  Log.info "Creating a partner"
+  kapi.post '/v0/partners', {
+    'name' => random_string,
+    'password' => random_string,
+    'is_testing' => true,
+    'display_name' => 'KGriftTestingPartner_' + random_string(16),
+    'rate_limit_multiplier' => 1.0,
+  }.merge(overrides)
+end
+
+def update_partner id, payload
+  Log.info "Updating partner: #{id}"
+  kapi.put "/v0/partners/#{id}", payload
+end
+
+def get_partner id
+  Log.info "Getting a partner: " + id
+  kapi.get "/v0/partners/#{id}"
+end
+
+def delete_partner id
+  Log.info "Deleting a partner: " + id
+  kapi.delete "/v0/partners/#{id}"
+end
+
+def create_system_user id
+  Log.info "Creating a system user for partner: " + id
+  kapi.post "/v0/partners/#{id}/system-user", nil
+end
+
+#this will not raise an error if 409 conflict
+# is returned on create call
+def ensure_partner_exists overrides={}
+  Log.info 'Ensuring partner exists: ' + overrides['name'].to_s
+  create_partner overrides
+  return true
+rescue Grifter::RequestException => e
+  if e.code == 409
+    Log.debug "Partner already exists"
+    return true
+  else
+    raise e
+  end
+end
+
+
+def set_partner_rate_limit_multiplier id, multiplier
+  partner = get_partner id
+  update_payload = partner.merge 'rate_limit_multiplier' => multiplier
+  update_payload.delete 'id'
+  update_partner id, update_payload
+end

data/KGrift/knewton_grifts/partner_support_grifts.rb

@@ -0,0 +1,85 @@
+#add_new_prod_partner is used for making production partners
+#it makes system users as well
+#by default it makes 1 system user and 1 old-style-system-user
+#you can alter either count through the options passed in
+def add_new_prod_partner display_name, options={}
+  if !display_name.kind_of?(String) || display_name.length < 3
+    raise "You must pass in a display name that is at least 3 characters long"
+  end
+  options.merge!({ 'display_name' => display_name })
+  set_prod_mode
+  set_account :prod_knerd
+  partner_data = add_new_partner options
+  print "\n\nNEW PARTNER:\n#{partner_data.to_yaml}\n"
+  partner_data
+end
+
+#add new test partner should be used anytime we are making
+#a partner for internal testing use. Test partner are NEVER
+#to be given externally as they are subject to being deleted without notice
+def add_new_partner options={}
+
+  options = {
+    'num_system_users' => 1,
+    'is_testing' => false,
+    'filename' => 'new_partner_data.json',
+    'display_name' => 'KnewtonTestingPartner_' + random_string(16),
+    'rate_limit_multiplier' => 1.0,
+  }.merge(options)
+
+  new_partner_data = {
+    'client_id' =>  options.fetch('client_id', random_string(32)),
+    'client_secret' => options.fetch('client_secret', random_string(48)),
+  }
+
+  partner = create_partner 'name' => new_partner_data['client_id'],
+    'password' => new_partner_data['client_secret'],
+    'is_testing' => options['is_testing'],
+    'display_name' => options['display_name'],
+    'rate_limit_multiplier' => options['rate_limit_multiplier']
+
+  new_partner_data['partner_id'] = partner['id']
+
+  if options['num_system_users'] > 0
+    new_partner_data['system_users'] = options['num_system_users'].times.map do
+      new_system_user = create_system_user new_partner_data['partner_id']
+      {
+        'external_user_id' => new_system_user['external_user_id'],
+        'account_id' => new_system_user['id'],
+      }
+    end
+  end
+
+  new_partner_data['created_on'] = DateTime.now.to_s
+  new_partner_data['created_by'] = Etc.getlogin
+
+  File.open(options['filename'], 'w')  do |f|
+    f.write(JSON.pretty_generate(new_partner_data))
+    Log.warn "Wrote the new partner data to #{options['filename']}"
+  end
+
+  return new_partner_data
+end
+
+def set_prod_mode
+  grifter_configuration[:services].keys.each do |svc|
+    self.send(svc).headers.delete 'knewton-test'
+  end
+  nil
+end
+
+def set_test_mode
+  grifter_configuration[:services].keys.each do |svc|
+    self.send(svc).headers['knewton-test'] = 'true'
+  end
+  nil
+end
+
+def get_client_id_from_partner_id partner_id
+  partner_record = nil
+  as_account :knerd do
+    partner_record = get_partner partner_id
+  end
+  partner_record['name']
+end
+

data/KGrift/knewton_grifts/recommendation_setup_grifts.rb

@@ -0,0 +1,215 @@
+"""
+Grifts to setup state to test recommendations.
+
+Use to setup tests verifying rec contracts. The terminology used is specified in the beginning of
+the Recommendations Contracts document:
+https://docs.google.com/document/d/1s0gBAPbBKdCUmkBmLh36tQk1-s9B7VD14sz22vWm4Ns/
+"""
+
+MAX_RANDOM_HISTORY_EVENTS=20
+
+def setup_test_scenario scenario, graph_type
+    set_account(:partner)
+    test_data = {}
+    #get graph, create learning instance/goal/student/registration
+    test_data['graph'] = (get_test_data :simple_graphs)[graph_type]
+    test_data['learning_instance'] = create_learning_instance graph_id: test_data['graph']['id']
+    test_data['goal'] = generate_specified_goal test_data['graph'], test_data['learning_instance']['id'], scenario['goal'], scenario['target_date_offset']
+    test_data['student'] = add_new_student_to_learning_instance test_data['learning_instance']['id']
+
+    generate_student_history scenario['history'], test_data
+
+    test_data
+end
+
+#Generate student history of a specified type-- currently either None or Any (random)
+def generate_student_history history_type, test_data
+    r = Random.new
+    if ENV.has_key? "REC_SEED"
+        r = Random.new ENV['REC_SEED']
+    end
+
+    case history_type
+    when "None"
+        return
+    when "Any"
+        num_events = r.rand(MAX_RANDOM_HISTORY_EVENTS)
+        num_events.times do
+            send_random_event_on_graph test_data['student']['registration_id'], test_data['graph']
+        end
+    end
+end
+
+#Default goal settings
+DEFAULT_TARGET_SCORE = 0.7
+DEFAULT_TARGET_DATE_OFFSET = 7
+def generate_specified_goal graph, learning_instance_id, goal_type, target_date_offset=DEFAULT_TARGET_DATE_OFFSET
+    case goal_type
+    when "G[T][T]"
+        #Goal with on single-concept graph of concept T, with:
+        #   - a single arbitrary assessment module within concept T
+        #   - all modules under concept T recommendable.
+
+        #select the single concept T
+        concept = find_concept_by_name graph, 'T'
+
+        #Pick the single assessment module under concept T.
+        assessing_module = find_associated_assessing_bndl graph, concept['id']
+
+        #Pick the all modules under concept T as recommendable.
+        rec_modules = find_associated_assessing_atoms graph, concept['id']
+
+        goal = create_goal learning_instance_id, {
+            'target_modules' => [ {
+                'module_id' => assessing_module,
+                'target_score' => DEFAULT_TARGET_SCORE,
+                'target_date' => days_from_now(target_date_offset),
+            }],
+            'recommendable_modules' => rec_modules.map{|m| { "module_id" => m } },
+        }
+    when "G[T][P1,T]"
+        #Goal with on single-concept graph of concept T, with:
+        #   - a single arbitrary assessment module within concept T
+        #   - all modules under concepts P1 and T recommendable.
+
+        #select concepts
+        concept_t = find_concept_by_name graph, 'T'
+        concept_p1 = find_concept_by_name graph, 'P1'
+
+        #Pick the single assessment module under concept T.
+        assessing_module = find_associated_assessing_bndl graph, concept_t['id']
+
+        #Pick the all modules under concept T as recommendable.
+        rec_modules = []
+        rec_modules.concat( find_associated_assessing_atoms graph, concept_t['id'] )
+        rec_modules.concat( find_associated_assessing_atoms graph, concept_p1['id'] )
+
+        goal = create_goal learning_instance_id, {
+            'target_modules' => [ {
+                'module_id' => assessing_module,
+                'target_score' => DEFAULT_TARGET_SCORE,
+                'target_date' => days_from_now(target_date_offset),
+            }],
+            'recommendable_modules' => rec_modules.map{|m| { "module_id" => m } },
+        }
+    when "G[T][all]"
+        #Goal with on single-concept graph of concept T, with:
+        #   - a single arbitrary assessment module within concept T
+        #   - all atoms in the graph recommendable.
+
+        #select concepts
+        concept_t = find_concept_by_name graph, 'T'
+
+        #Pick the single assessment module under concept T.
+        assessing_module = find_associated_assessing_bndl graph, concept_t['id']
+
+        #Pick the all atoms as recommendable.
+        rec_modules = find_all_atom_ids graph
+
+        goal = create_goal learning_instance_id, {
+            'target_modules' => [ {
+                'module_id' => assessing_module,
+                'target_score' => DEFAULT_TARGET_SCORE,
+                'target_date' => days_from_now(target_date_offset),
+            }],
+            'recommendable_modules' => rec_modules.map{|m| { "module_id" => m } },
+        }
+    when "G[P1][all]"
+        #Goal with on single-concept graph of concept P1, with:
+        #   - a single arbitrary assessment module within concept P1
+        #   - all atoms in the graph recommendable.
+
+        #select concepts
+        concept_p1 = find_concept_by_name graph, 'P1'
+
+        #Pick the single assessment module under concept P1.
+        assessing_module = find_associated_assessing_bndl graph, concept_p1['id']
+
+        #Pick the all atoms as recommendable.
+        rec_modules = find_all_atom_ids graph
+
+        goal = create_goal learning_instance_id, {
+            'target_modules' => [ {
+                'module_id' => assessing_module,
+                'target_score' => DEFAULT_TARGET_SCORE,
+                'target_date' => days_from_now(target_date_offset),
+            }],
+            'recommendable_modules' => rec_modules.map{|m| { "module_id" => m } },
+        }
+    else
+        throw "Unrecognized goal type #{goal_type}"
+    end
+end
+
+def complete_goal_with_percentage_correct registration_id, goal_id, percentage_correct, options={}
+    starting_event_threshold = 1.0 - percentage_correct
+
+    completion_data = complete_goal registration_id,
+        goal_id,
+        options.merge({:starting_event_threshold=>starting_event_threshold, :event_threshold_multiplier=>1.0})
+
+    completion_data
+end
+
+def complete_goal_with_percentage_correct_per_concept graph, registration_id, goal_id, percentages_correct, options={}
+    concept_thresholds = []
+
+    percentages_correct.each do |concept,percentage|
+        concept_thresholds << {
+            'id'=> (find_concept_by_name graph, concept)['id'],
+            'current_threshold' => (1.0-percentage),
+            'threshold_multiplier' => 1.0,
+            'num_fails_before_success' => 0,
+        }
+    end
+
+    completion_data = complete_goal registration_id,
+        goal_id,
+        options.merge({:concept_thresholds=>concept_thresholds})
+
+    completion_data
+end
+
+#Parses test data as used in the recommendations contracts tests, stripping irrelevent data and applying readable names
+def humanize_completion_data test_data, graph_type, scenario_title, scenario
+    human_data = {}
+    human_data['date'] = Time.now
+    human_data['env'] = ENV['GRIFTER_ENVIRONMENT']
+    human_data['contract'] = scenario_title
+    human_data['graph_type'] = graph_type
+    human_data['goal_type'] = scenario['goal']
+    human_data['is_goal_complete'] = test_data['completion_data']['event_count'] <= scenario['max_adaptive_cycles']
+    human_data['contract_vars'] = test_data['contract_vars']
+    if test_data['preliminary_event_bodies']
+        human_data['preliminary_events'] = test_data['preliminary_event_bodies'].map do |event|
+            humanize_event_body test_data['graph'], event
+        end
+    end
+    human_data['adaptive_cycles'] = test_data['completion_data']['event_bodies_sent'].map do |event|
+        humanize_event_body test_data['graph'], event
+    end
+    human_data['concepts'] = humanize_concept_data test_data['graph']
+
+    human_data
+end
+
+def humanize_event_body graph, event
+    node = get_node_with_concept_and_content_type graph, event['module_id']
+    cycle_data = {
+        'concept' => node['concept']['name'],
+        'content_type' => node['content_type'],
+        'is_correct' => event['is_correct'],
+        'module_id' => event['module_id'],
+    }
+end
+
+def humanize_concept_data graph
+    concepts = (find_all_concept_ids graph).map do |concept|
+        concept = get_node_by_id graph, concept
+        {'id' => concept['id'], 'name' => concept['name']}
+    end
+end
+
+def write_contract_yaml_report contract_filename, report_data
+    File.open("reports/contract_#{contract_filename}.yml", 'w') {|f| f.write YAML::dump(report_data) }
+end

data/KGrift/knewton_grifts/registration_grifts.rb

@@ -0,0 +1,159 @@
+##STUFF RELATING TO REGISTRATION RESOURCES
+def create_registration overrides={}
+  Log.info "Creating a registration"
+  # if account_id was passed in, we'll use that account id
+  # but, if account_id not provided, we'll make an account and return its details
+  account = nil
+  unless overrides['account_id']
+    account = create_account
+    overrides['account_id'] = account['id']
+  end
+  reg = kapi.post '/v0/registrations', {
+     'type' => 'learner',
+     'account_id' => nil,
+     'learning_instance_id' => '456',
+  }.merge(overrides)
+  reg['external_user_id'] = account['external_user_id'] if account
+  reg
+end
+
+def make_account_instructor_of account_id, learning_instance_id
+  Log.info "Creating a registration of type instructor for learning instance " + learning_instance_id + " account_id " + account_id
+  create_registration 'learning_instance_id' => learning_instance_id,
+                      'account_id' => account_id,
+                      'type' => "instructor"
+end
+
+
+def add_new_student_to_learning_instance learning_instance_id, client_credentials=nil, options={}
+  client_credentials = get_client_credentials(:knewton) unless client_credentials
+  account = create_account
+  external_user_id = account['external_user_id']
+  account_id = account['id']
+  registration = create_registration 'learning_instance_id' => learning_instance_id,
+                                     'account_id' => account_id,
+                                     'type' => options.fetch('type', 'learner')
+  {
+    'external_user_id' => external_user_id,
+    'registration_id' => registration['id'],
+    'account_id' => account_id,
+  }
+end
+
+def get_registration id
+  Log.info "Getting a registration " + id
+  kapi.get "/v0/registrations/#{id}"
+end
+
+def delete_registration id
+  Log.info "Deleting a registration " + id
+  kapi.delete "/v0/registrations/#{id}"
+end
+
+def get_registrations_for_account account_id
+  Log.info "Getting a registration for account " + account_id
+  kapi.get "/v0/accounts/#{account_id}/registrations"
+end
+
+
+##GOAL ACTIVATATION STUFF
+def activate_registration_on_goal learning_instance_id, registration_id, goal_id
+  Log.info "Activating a goal for a registration"
+  kapi.put "/v0/learning-instances/#{learning_instance_id}/goals/#{goal_id}/registrations/#{registration_id}", {}
+end
+
+def deactivate_registration_on_goal learning_instance_id, registration_id, goal_id
+  Log.info "Deactivating a goal for a registration"
+  kapi.delete "/v0/learning-instances/#{learning_instance_id}/goals/#{goal_id}/registrations/#{registration_id}"
+end
+
+def list_activated_registrations learning_instance_id, goal_id
+  Log.info "Listing activated registrations for a goal"
+end
+
+def check_if_activated learning_instance_id, registration_id, goal_id
+  Log.info "Checking if a specific registration is activated for a specific goal"
+  kapi.get "/v0/learning-instances/#{learning_instance_id}/goals/#{goal_id}/registrations/#{registration_id}"
+  return true
+rescue Grifter::RequestException => e
+  if e.code == 404
+    return false
+  else
+    raise e
+  end
+end
+
+
+##SENDING IN EVENTS STUFF
+def send_recommendation_followed registration_id, module_id, overrides={}
+  Log.info "Sending a recommendation followed event"
+  kapi.post "/v0/registrations/#{registration_id}/recommendation-followed-events", {
+    'module_id' => module_id,
+    'time_followed' => datetime,
+    'recommendation_id' => 987654,
+  }.merge(overrides)
+end
+
+def send_graded_event registration_id, module_id, overrides={}
+  Log.info "Sending a graded event"
+  kapi.post "/v0/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 send_ungraded_event registration_id, module_id, overrides={}
+  Log.info "Sending an ungraded event"
+  kapi.post "/v0/registrations/#{registration_id}/ungraded-events", {
+    'duration' =>             876543,
+    'module_id' =>            module_id,
+    'is_complete' =>          true,
+    'interaction_end_time' => datetime,
+  }.merge(overrides)
+end
+
+def send_focus_event registration_id, goal_id, overrides={}
+  Log.info "Sending a focus event"
+  kapi.post "/v0/registrations/#{registration_id}/focus-events", {
+    'goal_id' => goal_id,
+  }.merge(overrides)
+end
+
+def send_random_event_on_graph registration_id, graph
+    atom_id = find_random_atom_id graph
+    send_correct_event_type_for_atom registration_id, atom_id, graph
+end
+
+def send_correct_event_type_for_atom registration_id, atom_id, graph
+    content_types = get_content_types graph, atom_id
+
+    if content_types.include? 'assesssment'
+        correct = [true, false].sample
+        send_graded_event registration_id, atom_id, is_correct: correct
+    else
+        send_ungraded_event registration_id, atom_id
+    end
+end
+
+## GETTING RECOMMENDATION STUFF
+def 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 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/registrations/#{registration_id}/recommendation?#{query_string}"
+end
+
+def send_batch_events registration_id, events, overrides={}
+  Log.info "Sending a batch of student events"
+  kapi.post "/v0/registrations/#{registration_id}/batch-events", {
+    'goal_id' => nil,
+    'events' => events
+  }.merge(overrides)
+end