Fix #6322: Add IsProperSubsetOf to item-selection interaction

data/explorations/all_interactions/all_interactions.yaml

@@ -578,6 +578,7 @@ states:
       feedback_1: {}
       feedback_2: {}
       feedback_3: {}
+      feedback_4: {}
       hint_1: {}
     interaction:
       answer_groups:
@@ -629,6 +630,23 @@ states:
           rule_type: DoesNotContainAtLeastOneOf
         tagged_misconception_id: null
         training_data: []
+      - outcome:
+          dest: Item Selection Multi
+          feedback:
+            content_id: feedback_4
+            html: <p>That's good! No bad options, but make sure to choose all good options!</p>
+          labelled_as_correct: false
+          missing_prerequisite_skill_id: null
+          param_changes: []
+          refresher_exploration_id: null
+        rule_specs:
+        - inputs:
+            x:
+            - <p>Good option A.</p>
+            - <p>Good option C.</p>
+          rule_type: IsProperSubsetOf
+        tagged_misconception_id: null
+        training_data: []
       confirmed_unclassified_answers: []
       customization_args:
         choices:

extensions/interactions/ItemSelectionInput/directives/ItemSelectionInputRulesService.js

@@ -41,6 +41,16 @@ oppia.factory('itemSelectionInputRulesService', ['$filter', function($filter) {
       return normalizedInput.some(function(val) {
         return normalizedAnswer.indexOf(val) === -1;
       });
+    },
+    // This function checks if the answer
+    // given by the user is a subset of the correct answers.
+    IsProperSubsetOf: function(answer, inputs) {
+      var normalizedAnswer = $filter('removeDuplicatesInArray')(answer);
+      var normalizedInput = $filter('removeDuplicatesInArray')(inputs.x);
+      return normalizedAnswer.length < normalizedInput.length &&
+          normalizedAnswer.every(function(val) {
+            return normalizedInput.indexOf(val) !== -1;
+          });
     }
   };
 }]);

extensions/interactions/ItemSelectionInput/directives/ItemSelectionInputRulesServiceSpec.js

@@ -72,4 +72,20 @@ describe('Item Selection rules service', function() {
         ['a', 'b', 'c', 'd'], RULE_INPUT)).toBe(false);
     }
   );
+  it('should have a correct \'is a proper subset of\' rule',
+    function() {
+      var RULE_INPUT = {
+        x: ['a', 'b', 'c']
+      };
+      expect(isirs.IsProperSubsetOf([], RULE_INPUT)).toBe(true);
+      expect(isirs.IsProperSubsetOf(['a'], RULE_INPUT)).toBe(true);
+      expect(isirs.IsProperSubsetOf(['a', 'b'], RULE_INPUT)).toBe(true);
+      expect(isirs.IsProperSubsetOf(['a', 'b', 'c'], RULE_INPUT)).toBe(false);
+      expect(isirs.IsProperSubsetOf(['d', 'e'], RULE_INPUT)).toBe(false);
+      expect(isirs.IsProperSubsetOf(
+        ['a', 'b', 'c', 'd'], RULE_INPUT)).toBe(false);
+      expect(isirs.IsProperSubsetOf(
+        ['b', 'c', 'd', 'e'], RULE_INPUT)).toBe(false);
+    }
+  );
 });

extensions/interactions/ItemSelectionInput/directives/ItemSelectionInputValidationService.js

@@ -131,6 +131,8 @@ oppia.factory('ItemSelectionInputValidationService', [
                         'please select only one answer choice.')
                     });
                   }
+                } else if (rule.type === 'IsProperSubsetOf') {
+                  handledAnswers[choiceIndex] = true;
                 } else if (rule.type === 'ContainsAtLeastOneOf') {
                   handledAnswers[choiceIndex] = true;
                 } else if (rule.type ===
@@ -144,10 +146,30 @@ oppia.factory('ItemSelectionInputValidationService', [
               });
             });
           });
-          areAllChoicesCovered = handledAnswers.every(function(handledAnswer) {
-            return handledAnswer;
-          });
         }
+        answerGroups.forEach(function(answerGroup, answerIndex) {
+          var rules = answerGroup.rules;
+          rules.forEach(function(rule, ruleIndex) {
+            var ruleInputs = rule.inputs.x;
+            ruleInputs.forEach(function(ruleInput) {
+              if (rule.type === 'IsProperSubsetOf') {
+                if (ruleInputs.length < 2) {
+                  warningsList.push({
+                    type: WARNING_TYPES.ERROR,
+                    message: (
+                      'In answer group ' + (answerIndex + 1) + ', ' +
+                      'rule ' + (ruleIndex + 1) + ', the "proper subset" ' +
+                      'rule must include at least 2 options.')
+                  });
+                }
+              }
+            });
+          });
+        });
+
+        areAllChoicesCovered = handledAnswers.every(function(handledAnswer) {
+          return handledAnswer;
+        });
 
         if (!areAllChoicesCovered) {
           if (!defaultOutcome || defaultOutcome.isConfusing(stateName)) {

extensions/interactions/ItemSelectionInput/directives/ItemSelectionInputValidationServiceSpec.js

@@ -68,6 +68,17 @@ describe('ItemSelectionInputValidationService', function() {
       false,
       null)
     ];
+    IsProperSubsetValidOption = [agof.createNew(
+      [rof.createFromBackendDict({
+        rule_type: 'IsProperSubsetOf',
+        inputs: {
+          x: ['Selection 1']
+        }
+      })],
+      goodDefaultOutcome,
+      false,
+      null)
+    ];
   }));
 
   it('should be able to perform basic validation', function() {
@@ -165,4 +176,19 @@ describe('ItemSelectionInputValidationService', function() {
       message: 'Please ensure the choices are unique.'
     }]);
   });
+
+  it(
+    'should expect more that 1 element to be in the rule input, if the ' +
+    '"proper subset" rule is used.',
+    function() {
+      var warnings = validatorService.getAllWarnings(
+        currentState, customizationArguments, IsProperSubsetValidOption,
+        goodDefaultOutcome);
+      expect(warnings).toEqual([{
+        type: WARNING_TYPES.ERROR,
+        message: (
+          'In answer group 1, ' +
+          'rule 1, the "proper subset" rule must include at least 2 options.')
+      }]);
+    });
 });

extensions/interactions/rule_templates.json

@@ -97,6 +97,9 @@
     },
     "DoesNotContainAtLeastOneOf": {
       "description": "omits at least one of {{x|SetOfHtmlString}}"
+    },
+    "IsProperSubsetOf": {
+      "description": "is a proper subset of {{x|SetOfHtmlString}}"
     }
   },
   "LogicProof": {