kgrift 1.3.108

data/KGrift/knewton_grifts/graph_tools_grifts.rb

@@ -0,0 +1,151 @@
+"""
+GraphTools is the rest api begind the Bramble react application
+
+These grifts are used to power tests made directly against the graphtools
+api.
+"""
+
+# the way we authenticate for graphtools api is different from other services
+# other services use the knewton oauth2 provider.
+# graphtools uses google oauth2 provider in such a way that restricts the app/api to only those with @knewton.com emails
+#
+# The complexity of getting a google token is completely hidden in the graphtools_api_token test data generator
+def graphtools_authenticate
+  # these google tokens last something like 12ish hours...
+  # so we use the session_only option to get a single fresh one on each test run
+  token = get_test_data(:graphtools_api_token, session_only: true)['token']
+  graphtools.headers['Authorization'] = token
+  # return true to mean success
+  true
+end
+
+# Methods that adds additional headers needed by the graph editor endpoints
+def graph_editor_get partner_id, inventory_id, url
+  graphtools.get url, additional_headers: {
+    'Partner-Id' => partner_id,
+    'Inventory-Id' => inventory_id,
+  }
+end
+
+def graph_editor_post partner_id, inventory_id, url, body
+  graphtools.post url, body, additional_headers: {
+    'Partner-Id' => partner_id,
+    'Inventory-Id' => inventory_id,
+  }
+end
+
+def graph_editor_delete partner_id, inventory_id, url, body = {}
+  graphtools.do_request :delete, url, body, additional_headers: {
+    'Partner-Id' => partner_id,
+    'Inventory-Id' => inventory_id,
+  }
+end
+
+# Endpoints for graph editor
+# Pulling all modules from CoCo for a specific inventory
+def pull_modules_from_coco partner_id, inventory_id
+  graph_editor_post partner_id, inventory_id, "/graph", {}
+end
+
+# Clearing all the concepts and modules for a specific inventory
+def clear_graph_tools partner_id, inventory_id
+  graph_editor_post partner_id, inventory_id, "/graph/clear", {}
+end
+
+# Getting the difference between modules in CoCo and GraphTools
+def graph_diff partner_id, inventory_id
+  graph_editor_get partner_id, inventory_id, "/graph/delta"
+end
+
+# Getting number of modules that are different in CoCo and GraphTools
+def graph_diff_summary partner_id, inventory_id
+  graph_editor_get partner_id, inventory_id, "/graph/delta-summary"
+end
+
+# Create concept for an inventory
+def graphtools_create_concept partner_id, inventory_id, concept={}
+  graph_editor_post partner_id, inventory_id, "/concepts/concept", concept
+end
+
+# Update concept for an inventory
+def graphtools_update_concept partner_id, inventory_id, concept={}
+  graph_editor_post partner_id, inventory_id, "/concepts/concept/update", concept
+end
+
+# Get a specific concept for an inventory
+def graphtools_get_concept partner_id, inventory_id, concept_id
+  graph_editor_get partner_id, inventory_id, "/concepts/concept?#{URI.encode_www_form concept_id}"
+end
+
+# Delete a specific concept for an inventory
+def graphtools_delete_concept partner_id, inventory_id, concept_id
+  graph_editor_delete partner_id, inventory_id, "/concepts/concept/#{URI.encode concept_id}"
+end
+
+# Get a specific module from an inventory
+def graphtools_get_module partner_id, inventory_id, module_id
+  graph_editor_get partner_id, inventory_id, "/modules/module?#{URI.encode_www_form module_id}"
+end
+
+# Getting modules from an inventory
+def graphtools_get_modules partner_id, inventory_id, query_params={}
+  graph_editor_get partner_id, inventory_id, "/modules?#{URI.encode_www_form query_params}"
+end
+# Getting modules from an inventory
+def graphtools_get_concepts partner_id, inventory_id, query_params={}
+  graph_editor_get partner_id, inventory_id, "/concepts?#{URI.encode_www_form query_params}"
+end
+
+# Create a concept-concept edge and return the updated concept
+def graphtools_create_cc_edge partner_id, inventory_id, edge
+  graph_editor_post partner_id, inventory_id, "/concepts/edge/concept", edge
+end
+# Delete a concept-concept edge and return the updated concept
+def graphtools_delete_cc_edge partner_id, inventory_id, edge
+  graph_editor_delete partner_id, inventory_id, "/concepts/edge/concept", edge
+end
+
+# Create a concept-module edge and return the updated concept
+def graphtools_create_cm_edge partner_id, inventory_id, edge
+  graph_editor_post partner_id, inventory_id, "/concepts/edge/module", edge
+end
+# Delete a concept-module edge and return the updated concept
+def graphtools_delete_cm_edge partner_id, inventory_id, edge
+  graph_editor_delete partner_id, inventory_id, "/concepts/edge/module", edge
+end
+
+# Create a concept-module edge and return the updated module
+def graphtools_create_mc_edge partner_id, inventory_id, edge
+  graph_editor_post partner_id, inventory_id, "/modules/edge/concept", edge
+end
+# Delete a concept-module edge and return the updated module
+def graphtools_delete_mc_edge partner_id, inventory_id, edge
+  graph_editor_delete partner_id, inventory_id, "/modules/edge/concept", edge
+end
+
+# this is a unique function in that it writes a spreadsheet file
+# the return is the path to the spreadsheet
+def graphtools_get_graph_spreadsheet partner_id, inventory_id
+  # we need to customize the headers for this to work...
+  # so this request is being constructed in a very custom way...
+  url = "/graph/spreadsheet"
+  response = graphtools.get url, additional_headers: {
+    'Partner-Id' => partner_id,
+    'Inventory-Id' => inventory_id,
+    'accept' => '*/*',
+  }
+  # response is the binary of the spreadsheet.  Just dump it into a file...
+  # fist make a path to a file
+  # path is designed to be a) findable by including inventory_id / partner_id
+  # b) random, so that no possibility of tests using wrong file occurs
+  tmp_folder = 'tmp'
+  suppress(Exception) { Dir.mkdir tmp_folder }
+  filename = "test_spreadsheet_#{partner_id}_#{inventory_id}_#{random_string(8)}.xlsx"
+  path = File.join tmp_folder, filename
+  # second write the response into the file
+  File.open(path, 'w') do |f|
+    f.write response
+  end
+  path
+end
+

data/KGrift/knewton_grifts/graph_validation_grifts.rb

@@ -0,0 +1,447 @@
+"""
+This hunk of code is all about validating whether a known graph id 'works'.
+It does this by sending student events against every module in the graph,
+ensuring in each case a new recommentation is produced
+"""
+
+def send_all_events_against_graph_and_goal graph_id, learning_instance_id, goal_id, num_regs
+  #cache the graph
+  graph = get_graph_and_cache_it graph_id
+
+  #create a num_regs new students and activate on the same goal
+  students = []
+  num_regs.to_i.times do
+    #add new student and activate on goal
+    student = (add_new_student_to_learning_instance learning_instance_id)['registration_id']
+    activate_registration_on_goal learning_instance_id, student, goal_id
+    #get an initial recommendation
+    get_next_recommendation_in_flow student, goal_id, nil
+    #save the student registration id
+    students << student
+  end
+
+  #iterate over all concepts
+  all_concepts = find_all_concept_ids graph
+  Log.info "Found #{all_concepts.length} concepts in total"
+  all_concepts.each do |concept|
+    Log.info "CONCEPT #{all_concepts.index(concept)+1}/#{all_concepts.length}"
+    Log.info "Finding all associated modules for concept #{concept}"
+    #find all modules by type
+    all_modules = []
+    all_modules << find_associated_assessing_atoms(graph,concept).map{|m| {'id' => m,
+                                                                           'type' => 'atom',
+                                                                           'content' => 'assessment'}}
+    all_modules << find_associated_assessing_bndls(graph,concept).map{|m| {'id' => m,
+                                                                           'type' => 'bndl',
+                                                                           'content' => 'assessment'}}
+    all_modules << find_associated_instructional_atoms(graph,concept).map{|m| {'id' => m,
+                                                                               'type' => 'atom',
+                                                                               'content' => 'instructional'}}
+    all_modules << find_associated_instructional_bndls(graph,concept).map{|m| {'id' => m,
+                                                                               'type' => 'bndl',
+                                                                               'content' => 'instructional'}}
+    #iterate over all modules
+    #filter out duplicates and give preference to assessmen content (graded events)
+    mod_list = []
+    all_modules.flatten.each do |mod|
+      next if mod_list.include?(mod['id'])
+      student = students.rotate!.first
+      #send events by module category
+      if mod['type'] == 'bndl' or mod['content'] == 'instructional'
+        Log.info "Sending ungraded event for #{mod['content']} #{mod['type']} #{mod['id']}"
+        send_ungraded_event student, mod['id']
+      else
+        Log.info "Sending graded event for #{mod['content']} #{mod['type']} #{mod['id']}"
+        send_graded_event student, mod['id']
+      end
+      mod_list << mod['id']
+      puts ""
+      #slow down the rate to below 15r/s
+      sleep(2.0/10.0)
+    end
+  end
+
+  #get a final recommendation for each registration
+  Log.info "Getting a final recommendation"
+  num_regs.to_i.times do |i|
+    get_next_recommendation_in_flow students[i], goal_id, nil
+  end
+end
+
+def complete_goal_based_on_graph graph_id
+  #get graph
+  graph = get_graph_and_cache_it graph_id
+  puts "Loaded and cached graph #{graph_id}"
+
+  #get recommendable modules (based on graph)
+  rec_modules = find_all_recommendable_module_ids graph
+  puts "Number of recommendable modules: #{rec_modules.length}"
+
+  #define goal choosing prereq module
+  target_concept = find_prerequisite_concept graph
+  target_bndl = find_associated_assessing_bndl graph, target_concept
+  goal_obj = {
+               'target_modules' => [
+               {
+                 'module_id' => target_bndl,
+                 'target_date' => days_from_now(100),
+                 'target_score' => 0.6,
+               }
+               ],
+               'max_recommendation_size' => 3,
+               'start_date' => datetime,
+               'recommendable_modules' => rec_modules.map{|m| {'module_id' => m}},
+  }
+  learning_instance = create_learning_instance 'graph_id' => graph['id']
+  goal = create_goal learning_instance['id'], goal_obj
+  puts "Created learning instance #{learning_instance['id']}; using goal-id #{goal['id']}"
+
+  #add student to learning instance
+  student = add_new_student_to_learning_instance learning_instance['id']
+  activate_registration_on_goal learning_instance['id'], student['registration_id'], goal['id']
+  puts "Added student and activated registration"
+
+  #complete goal
+  completion_data = complete_goal student['registration_id'], goal['id']
+
+  #delete registration and learning instance
+  delete_registration student['registration_id']
+  delete_learning_instance learning_instance['id']
+
+  #return goal completion data
+  completion_data
+end
+
+def graph_passes_mega_validation? graph_id
+  graph_passes_mega_validation_multithreaded? graph_id, 1
+end
+
+def graph_passes_mega_validation_multithreaded? graph_id, num_threads
+  #get graph
+  graph = get_graph_and_cache_it graph_id
+  puts "Loaded and cached graph: #{graph_id}"
+
+  #get recommendable modules (based on graph)
+  all_concepts = find_all_concept_ids graph
+  puts "Number of concepts: #{all_concepts.length}"
+
+  #define goal (choose post-requisite concept as target)
+  target_concept = find_post_requisite_concept graph
+  target_bndl = find_associated_assessing_bndl graph, target_concept
+  if target_bndl==nil
+    puts "Validation FAILED: concept #{target_concept} has no associated assessment bundle."
+    return false
+  end
+  rec_modules = find_all_recommendable_module_ids graph
+  goal_obj = {
+               'target_modules' => [
+               {
+                 'module_id' => target_bndl,
+                 'target_date' => days_from_now(100),
+                 'target_score' => 0.99,
+               }
+               ],
+               'max_recommendation_size' => 3,
+               'start_date' => datetime,
+               'recommendable_modules' => rec_modules.map{|m| {'module_id' => m}},
+  }
+
+  #Fork n threads
+  mutex = Mutex.new
+  abort_mutex = Mutex.new
+  abort_flag = 0
+  fail_flag = Array.new(num_threads.to_i, 0)
+  learning_id = Array.new(num_threads.to_i,nil)
+  reg_id = Array.new(num_threads.to_i,nil)
+  threads = (0..(num_threads.to_i-1)).map do |i|
+    Thread.new(i) do |i|
+      #create unique learning instance and activate registration
+      goal = nil
+      student = nil
+      mutex.synchronize do
+        learning_instance = create_learning_instance 'graph_id' => graph['id']
+        learning_id[i] = learning_instance['id']
+        goal = create_goal learning_instance['id'], goal_obj
+        puts "Created learning instance #{learning_instance['id']} for goal id #{goal['id']}"
+        student = add_new_student_to_learning_instance learning_instance['id']
+        reg_id[i] = student['registration_id']
+        activate_registration_on_goal learning_instance['id'], student['registration_id'], goal['id']
+        puts "Added student and activated registration"
+      end
+
+      #define per-thread module partitions
+      start_concept = (all_concepts.length*i.to_f/num_threads.to_i).floor
+      end_concept = (all_concepts.length*(i.to_f+1)/num_threads.to_i).floor-1
+
+      #send events and grab recommendations for all modules
+      puts "Sending events and receiving recommendations..."
+      concept_counter = start_concept
+      all_concepts[start_concept..end_concept].each do |concept|
+        concept_counter += 1
+        puts ""
+
+        #exit when abort flag set
+        break if abort_flag==1
+
+        #skip iteration if concept is target concept
+        if (concept == target_concept)
+          puts "CONCEPT #{concept_counter}: skipped target concept: #{concept}"
+          next
+        end
+
+        #get next recommendation; set fail and abort flags if event duplicated
+        begin
+          current_recommendation = get_next_recommendation_in_flow student['registration_id'], goal['id'], current_recommendation
+          puts "CONCEPT #{concept_counter}: received new recommendation: #{current_recommendation['recommendation_id']}"
+          puts current_recommendation
+        rescue ExpectationError => error
+          fail_flag[i] = 1
+          puts "CONCEPT #{concept_counter}: received a duplicate recommendation: #{current_recommendation['recommendation_id']}"
+          abort_mutex.synchronize do
+            abort_flag = 1
+          end
+          puts "Validationn FAILED: recommendation duplicated: concept #{concept}."
+          break
+        end
+
+        #find current concept's associate assessing bundle and send graded event
+        assessing_bndl = find_associated_assessing_bndl graph, concept
+        assessing_bndl = (find_associated_assessing_atom graph, concept) unless assessing_bndl!=nil
+        if assessing_bndl==nil
+          fail_flag[i] = 1
+          puts "Validation FAILED: concept #{target_concept} has no associated assessment bundle."
+          abort_mutex.synchronize do
+            abort_flag = 1
+          end
+          break
+        end
+        puts "CONCEPT #{concept_counter}: concept #{concept} assessed by bundle #{assessing_bndl}"
+        event_body = generate_graded_event_body assessing_bndl, graph
+        mutex.synchronize do
+          send_graded_event student['registration_id'], nil, event_body
+        end
+      end
+
+      #get final recommendation
+      unless abort_flag==1
+        begin
+          current_recommendation = get_next_recommendation_in_flow student['registration_id'], goal['id'], current_recommendation
+          puts "CONCEPT #{concept_counter}: received new recommendation: #{current_recommendation['recommendation_id']}"
+          puts current_recommendation
+        rescue ExpectationError => error
+          fail_flag[i] = 1
+          puts "CONCEPT #{concept_counter}: received a duplicate recommendation: #{current_recommendation['recommendation_id']}"
+          abort_mutex.synchronize do
+            abort_flag = 1
+          end
+          puts "Validationn FAILED: recommendation duplicated following event sent to concept #{all_concepts[end_concept]}."
+        end
+      end
+    end
+  end
+  threads.each {|t| t.join}
+
+  #cleanup and return true, or return false if fail flag raised (without cleanup)
+  if fail_flag.reduce(:+) == 0
+    #delete registration and learning instance
+    (0..(num_threads.to_i-1)).each do |j|
+      delete_registration reg_id[j]
+      delete_learning_instance learning_id[j]
+    end
+    return true
+  else
+    return false
+  end
+end
+alias :graph_mega_validation :graph_passes_mega_validation_multithreaded?
+
+def graph_passes_taxon_mega_validation_multithreaded? graph_id, num_threads
+  #get graph
+  graph = get_graph_and_cache_it graph_id
+  puts "Loaded and cached graph: #{graph_id}"
+
+  #get recommendable modules (based on graph)
+  all_concepts = find_all_concept_ids graph
+  all_atoms = graph['nodes'].select{|n| n['type']=='module' and
+                                        n['subtype']=='atom'
+                                   }.map{|n| n['id']}
+  all_bndls = graph['nodes'].select{|n| n['type']=='module' and
+                                        n['subtype']=='bndl'
+                                   }.map{|n| n['id']}
+  puts "Number of concepts: #{all_concepts.size}"
+  puts "Number of modules: #{(all_atoms+all_bndls).size}"
+
+  #get all taxons
+  all_taxons = get_all_graph_taxonomies graph
+  puts "Number of taxons: #{all_taxons.size}"
+
+  #define goal (choose post-requisite concept as target)
+  target_concept = find_post_requisite_concept graph
+  target_bndl = find_associated_assessing_bndl graph, target_concept
+  if target_bndl==nil
+    puts "Validation FAILED: concept #{target_concept} has no associated assessment bundle."
+    return false
+  end
+  rec_modules = find_all_recommendable_module_ids graph
+  goal_obj = {
+               'target_modules' => [
+               {
+                 'module_id' => target_bndl,
+                 'target_date' => days_from_now(100),
+                 'target_score' => 0.99,
+               }
+               ],
+               'max_recommendation_size' => 3,
+               'start_date' => datetime,
+               'recommendable_modules' => rec_modules.map{|m| {'module_id' => m}},
+  }
+
+  #get list of all assessment modules (bundles and atoms)
+  puts "Retrieving all assessment modules..."
+  assessment_modules = find_all_assessment_modules graph
+  puts "Number of assessment modules: #{assessment_modules.size}"
+
+  #Fork n threads
+  mutex = Mutex.new
+  abort_mutex = Mutex.new
+  abort_flag = 0
+  fail_flag = Array.new(num_threads.to_i, 0)
+  learning_id = Array.new(num_threads.to_i,nil)
+  reg_id = Array.new(num_threads.to_i,nil)
+  threads = (0..(num_threads.to_i-1)).map do |i|
+    Thread.new(i) do |i|
+      #create unique learning instance and activate registration
+      goal = nil
+      student = nil
+      mutex.synchronize do
+        learning_instance = create_learning_instance 'graph_id' => graph['id']
+        learning_id[i] = learning_instance['id']
+        goal = create_goal learning_instance['id'], goal_obj
+        puts "Created learning instance #{learning_instance['id']} for goal id #{goal['id']}"
+        student = add_new_student_to_learning_instance learning_instance['id']
+        reg_id[i] = student['registration_id']
+        activate_registration_on_goal learning_instance['id'], student['registration_id'], goal['id']
+        puts "Added student and activated registration"
+      end
+
+      #define per-thread module partitions
+      start_taxon = (all_taxons.length*i.to_f/num_threads.to_i).floor
+      end_taxon = (all_taxons.length*(i.to_f+1)/num_threads.to_i).floor-1
+
+      #send events and grab recommendations for all modules
+      puts "Sending events and receiving recommendations..."
+      taxon_counter = start_taxon
+      all_taxons[start_taxon..end_taxon].each do |taxon|
+        taxon_counter += 1
+        puts ""
+
+        #exit when abort flag set
+        if abort_flag==1
+          break
+        end
+
+        #get next recommendation; set fail and abort flags if event duplicated
+        begin
+          current_recommendation = get_next_recommendation_in_flow student['registration_id'], goal['id'], current_recommendation
+          puts "TAXON #{taxon_counter}: received new recommendation: #{current_recommendation['recommendation_id']}"
+          puts current_recommendation
+        rescue ExpectationError => error
+          fail_flag[i] = 1
+          puts "TAXON #{taxon_counter}: received a duplicate recommendation: #{current_recommendation['recommendation_id']}"
+          abort_mutex.synchronize do
+            abort_flag = 1
+          end
+          puts "Validationn FAILED: recommendation duplicated: taxon #{taxon}."
+          break
+        end
+
+        #find random module in current taxon
+        assessing_module = (get_modules_by_taxonomy graph, taxon).select{|module_id| assessment_modules.include?(module_id)}.sample
+        if assessing_module==nil
+          fail_flag[i] = 1
+          puts "Validation FAILED: taxon #{target_taxon} has no associated assessment atoms or bundles."
+          abort_mutex.synchronize do
+            abort_flag = 1
+          end
+          break
+        end
+        puts "TAXON #{taxon_counter}: taxon #{taxon} assessed by bundle #{assessing_module}"
+        event_body = generate_graded_event_body assessing_module, graph
+        mutex.synchronize do
+          send_graded_event student['registration_id'], nil, event_body
+        end
+      end
+
+      #get final recommendation
+      unless abort_flag==1
+        begin
+          current_recommendation = get_next_recommendation_in_flow student['registration_id'], goal['id'], current_recommendation
+          puts "TAXON #{taxon_counter}: received new recommendation: #{current_recommendation['recommendation_id']}"
+          puts current_recommendation
+        rescue ExpectationError => error
+          fail_flag[i] = 1
+          puts "TAXON #{taxon_counter}: received a duplicate recommendation: #{current_recommendation['recommendation_id']}"
+          abort_mutex.synchronize do
+            abort_flag = 1
+          end
+          puts "Validationn FAILED: recommendation duplicated following event sent to module #{assessing_module} in taxon #{all_taxons[end_taxon]}."
+        end
+      end
+    end
+  end
+  threads.each {|t| t.join}
+
+  #cleanup and return true, or return false if fail flag raised (without cleanup)
+  if fail_flag.reduce(:+) == 0
+    #delete registration and learning instance
+    (0..(num_threads.to_i-1)).each do |j|
+      delete_registration reg_id[j]
+      delete_learning_instance learning_id[j]
+    end
+    return true
+  else
+    return false
+  end
+end
+alias :graph_taxon_mega_validation :graph_passes_taxon_mega_validation_multithreaded?
+
+
+#Helper function: generates custom event body for graded event; if bundle, chooses one atom at random
+def generate_graded_event_body module_id, graph, options={}
+  node_type = get_node_type graph, module_id
+  atom_ids = case node_type
+             when 'atom'
+               [module_id]
+             when 'bndl'
+               [module_id] + graph['edges'].select{|e| e['type'] == 'contains' and e['start'] == module_id}.map{|e| e['end']}
+             end
+  pick_module = atom_ids.sample
+  puts "Sending event for module: #{pick_module}"
+
+  event_body = generate_event_body(:graded, options).merge({'module_id' => pick_module})
+end
+
+#traverses graph searching for concepts without assessment modules
+def find_concepts_without_assessment_modules graph_id
+  graph = get_graph_and_cache_it graph_id
+  all_concepts = find_all_concept_ids graph
+  empty_concepts = []
+  all_concepts.each do |concept|
+    bndls=[]
+    atoms=[]
+    bndls = find_associated_assessing_bndl graph, concept
+    atoms = find_associated_assessing_atom graph, concept
+    if bndls==nil and atoms==nil
+      empty_concepts << concept
+      puts concept
+    end
+  end
+  puts ""
+  if empty_concepts.empty?
+    puts "All concepts have at least one assessment module"
+  else
+    puts "The following concepts do not have assessment modules:"
+  end
+  empty_concepts
+end
+