Test corner cases part 2

lib/celery_script/checker.rb

@@ -14,6 +14,23 @@ module CeleryScript
       tree
     end
 
+    def run
+      error || tree
+    end
+    
+    def valid?
+      error ? false : true
+    end
+
+    def error
+      run!
+      nil
+    rescue TypeCheckError => e
+      e
+    end
+
+    private
+
     def validate_node(node)
       check_arity(node)
       node.args.map do |array|
@@ -25,10 +42,10 @@ module CeleryScript
     end
 
     def check_arity(node)
-      corpus
+        allowed = corpus
         .fetchNode(node.kind)
         .allowed_args
-        .map do |arg|
+        allowed.map do |arg|
           has_key = node.args.has_key?(arg) || node.args.has_key?(arg.to_s)
           unless has_key
           msg = "Expected node '#{node.kind}' to have a '#{arg}',"\
@@ -38,7 +55,11 @@ module CeleryScript
         end
       has      = node.args.keys.map(&:to_sym) # Either bigger or equal.
       required = corpus.fetchNode(node.kind).allowed_args # Always smallest.
-      raise TypeCheckError unless (has.length === required.length)
+      if !(has.length === required.length)
+        extras = has - required
+        raise TypeCheckError, "'#{node.kind}' has unexpected arguments: "\
+                              "#{extras}. Allowed arguments: #{allowed}"
+      end
     end
 
     def check_arg_validity(should_be, node)
@@ -57,7 +78,8 @@ module CeleryScript
                                 "#{ allowed.inspect } but got #{ actual.inspect }"
         end
       else
-        raise TypeCheckError, "What was that?"
+        raise TypeCheckError, "Expected '#{should_be}' to be a node or leaf, "\
+                              "but it was neither"
       end
       validator = corpus.fetchArg(should_be).additional_validation
       validator.call(node, TypeCheckError, corpus) if(validator)

spec/lib/celery_script/checker_spec.rb

@@ -41,10 +41,34 @@ describe CeleryScript::Checker do
       .defineNode(:sequence,       [], steps)
   end
 
+  let (:checker) { CeleryScript::Checker.new(tree, corpus) }
+
   it "runs through a syntactically valid program" do
-      checker = CeleryScript::Checker.new(tree, corpus)
       outcome = checker.run!
       expect(outcome).to be_kind_of(CeleryScript::AstNode)
-      expect(outcome.comment).to eq("Properly formatted, syntactically valid sequence.")
+      expect(outcome.comment).to eq("Properly formatted, syntactically valid"\
+                                    " sequence.")
+  end
+
+  it "handles missing args" do
+    tree.body.first.args.delete(:x)
+    expect(checker.valid?).to be(false)
+    msg = checker.error.message
+    expect(msg).to include("Expected node 'move_absolute' to have a 'x'")
+  end
+
+  it "handles unknown args" do
+    tree.body.first.args["foo"] = "bar"
+    expect(checker.valid?).to be(false)
+    msg = checker.error.message
+    expect(msg).to eq("'move_absolute' has unexpected arguments: [:foo]."\
+                      " Allowed arguments: [:x, :y, :z, :speed]")
+  end
+
+  it "handles malformed / wrong type args" do
+    tree.body.first.args[:x] = "WRONG!"
+    expect(checker.valid?).to be(false)
+    msg = checker.error.message
+    expect(msg).to eq("Expected 'x' to be a node or leaf, but it was neither")
   end
 end