Don't define method body for abstract stub method

Test inheriting an abstract class with mocks.

spec/spectator/mocks/mock_spec.cr

@@ -6,6 +6,7 @@ Spectator.describe Spectator::Mock do
   let(stub3) { Spectator::ValueStub.new(:method3, "stubbed") }
 
   describe "#define_subtype" do
+    context "with a concrete class" do
       class Thing
         def method1
           42
@@ -69,6 +70,73 @@ Spectator.describe Spectator::Mock do
       end
     end
 
+    context "with an abstract class" do
+      abstract class Thing
+        abstract def method1
+
+        abstract def method2 : Symbol
+
+        def method3
+          "original"
+        end
+
+        abstract def method4
+      end
+
+      Spectator::Mock.define_subtype(:class, Thing, MockThing, :mock_name, method2: :stubbed) do
+        stub def method1 : Int32 # NOTE: Return type is required since one wasn't provided in the parent.
+          123
+        end
+      end
+
+      let(mock) { MockThing.new }
+
+      it "defines a subclass of the mocked type" do
+        expect(MockThing).to be_lt(Thing)
+      end
+
+      it "overrides responses from methods defined in the block" do
+        expect(mock.method1).to eq(123)
+      end
+
+      it "overrides responses from methods with keyword arguments" do
+        expect(mock.method2).to eq(:stubbed)
+      end
+
+      it "allows methods to be stubbed" do
+        aggregate_failures do
+          expect { mock._spectator_define_stub(stub1) }.to change { mock.method1 }.to(777)
+          expect { mock._spectator_define_stub(stub2) }.to change { mock.method2 }.to(:override)
+          expect { mock._spectator_define_stub(stub3) }.to change { mock.method3 }.from("original").to("stubbed")
+        end
+      end
+
+      it "can clear stubs" do
+        mock._spectator_define_stub(stub1)
+        mock._spectator_define_stub(stub2)
+        mock._spectator_define_stub(stub3)
+
+        mock._spectator_clear_stubs
+        aggregate_failures do
+          expect(mock.method1).to eq(123)
+          expect(mock.method2).to eq(:stubbed)
+          expect(mock.method3).to eq("original")
+        end
+      end
+
+      it "raises when calling an abstract method that isn't stubbed" do
+        expect { mock.method4 }.to raise_error(Spectator::UnexpectedMessage, /method4/)
+      end
+
+      it "sets the mock name" do
+        args = Spectator::Arguments.capture("foo")
+        stub = Spectator::ValueStub.new(:method3, 0, args)
+        mock._spectator_define_stub(stub)
+        expect { mock.method3 }.to raise_error(Spectator::UnexpectedMessage, /mock_name/), "Raised error doesn't contain the mocked name."
+      end
+    end
+  end
+
   describe "#inject" do
     context "with a class" do
       class MockedClass

src/spectator/mocks/stubbable.cr

@@ -316,14 +316,16 @@ module Spectator
                          meth.name.starts_with?("_spectator") ||
                            ::Spectator::DSL::RESERVED_KEYWORDS.includes?(meth.name.symbolize)
                        end %}
-        {{(method.abstract? ? :abstract_stub : :default_stub).id}} {{method.visibility.id if method.visibility != :public}} def {{method.receiver}}{{method.name}}(
+        {{(method.abstract? ? :"abstract_stub abstract" : :default_stub).id}} {{method.visibility.id if method.visibility != :public}} def {{method.receiver}}{{method.name}}(
           {% for arg, i in method.args %}{% if i == method.splat_index %}*{% end %}{{arg}}, {% end %}
           {% if method.double_splat %}**{{method.double_splat}}, {% end %}
           {% if method.block_arg %}&{{method.block_arg}}{% elsif method.accepts_block? %}&{% end %}
         ){% if method.return_type %} : {{method.return_type}}{% end %}{% if !method.free_vars.empty? %} forall {{method.free_vars.splat}}{% end %}
+          {% unless method.abstract? %}
             {% if type == @type %}previous_def{% else %}super{% end %}{% if method.accepts_block? %} { |*%yargs| yield *%yargs }{% end %}
           end
         {% end %}
+      {% end %}
     end
 
     # Utility macro for casting a stub (and it's return value) to the correct type.