Add specs of snippets from docs

spec/docs/getting_started_spec.cr

@@ -0,0 +1,23 @@
+require "../spec_helper"
+
+Spectator.describe String do
+  subject { "foo" }
+
+  describe "#==" do
+    context "with the same value" do
+      let(value) { subject.dup }
+
+      it "is true" do
+        is_expected.to eq(value)
+      end
+    end
+
+    context "with a different value" do
+      let(value) { "bar" }
+
+      it "is false" do
+        is_expected.to_not eq(value)
+      end
+    end
+  end
+end

spec/docs/helper_methods_spec.cr

@@ -0,0 +1,57 @@
+Spectator.describe String do
+  # This is a helper method.
+  def random_string(length)
+    chars = ('a'..'z').to_a
+    String.build(length) do |builder|
+      length.times { builder << chars.sample }
+    end
+  end
+
+  describe "#size" do
+    subject { random_string(10).size }
+
+    it "is the length of the string" do
+      is_expected.to eq(10)
+    end
+  end
+end
+Spectator.describe String do
+  # length is now pulled from value defined by `let`.
+  def random_string
+    chars = ('a'..'z').to_a
+    String.build(length) do |builder|
+      length.times { builder << chars.sample }
+    end
+  end
+
+  describe "#size" do
+    let(length) { 10 } # random_string uses this.
+    subject { random_string.size }
+
+    it "is the length of the string" do
+      is_expected.to eq(length)
+    end
+  end
+end
+
+module StringHelpers
+  def random_string
+    chars = ('a'..'z').to_a
+    String.build(length) do |builder|
+      length.times { builder << chars.sample }
+    end
+  end
+end
+
+Spectator.describe String do
+  include StringHelpers
+
+  describe "#size" do
+    let(length) { 10 }
+    subject { random_string.size }
+
+    it "is the length of the string" do
+      is_expected.to eq(length)
+    end
+  end
+end

spec/docs/mocks/mocks_spec.cr

@@ -0,0 +1,30 @@
+class Phonebook
+  def find(name)
+    # Some expensive lookup call.
+    "+18005554321"
+  end
+end
+
+class Resolver
+  def initialize(@phonebook : Phonebook)
+  end
+
+  def find(name)
+    @phonebook.find(name)
+  end
+end
+
+Spectator.describe Resolver do
+  mock Phonebook do
+    stub find(name)
+  end
+
+  describe "#find" do
+    it "can find number" do
+      pb = Phonebook.new
+      allow(pb).to receive(find).and_return("+18005551234")
+      resolver = Resolver.new(pb)
+      expect(resolver.find("Bob")).to eq("+18005551234")
+    end
+  end
+end

spec/docs/mocks/overview_spec.cr

@@ -0,0 +1,40 @@
+require "../../spec_helper"
+
+Spectator.describe "Doubles" do
+  double :my_double do
+    stub answer { 42 }
+  end
+
+  specify "the answer to everything" do
+    dbl = double(:my_double)
+    expect(dbl.answer).to eq(42)
+  end
+end
+
+class MyType
+  def answer
+    123
+  end
+end
+
+Spectator.describe "Mocks" do
+  mock MyType do
+    stub answer { 42 }
+  end
+
+  specify "the answer to everything" do
+    m = MyType.new
+    expect(m.answer).to eq(42)
+  end
+end
+Spectator.describe "Mocks and doubles" do
+  double :my_double do
+    stub answer : Int32 # Return type required, otherwise nil is assumed.
+  end
+
+  specify "the answer to everything" do
+    dbl = double(:my_double)
+    allow(dbl).to receive(:answer).and_return(42)
+    expect(dbl.answer).to eq(42)
+  end
+end

spec/docs/mocks/stubs_spec.cr

@@ -0,0 +1,166 @@
+require "../../spec_helper"
+
+Spectator.describe "Stubs" do
+  context "Implementing a Stub" do
+    double :my_double do
+      stub answer : Int32
+      stub do_something
+    end
+
+    it "knows the answer" do
+      dbl = double(:my_double)
+      allow(dbl).to receive(:answer).and_return(42)
+      expect(dbl.answer).to eq(42)
+    end
+
+    it "does something" do
+      dbl = double(:my_double)
+      allow(dbl).to receive(:do_something)
+      expect(dbl.do_something).to be_nil
+    end
+
+    context "and_return" do
+      double :my_double do
+        stub to_s : String
+        stub do_something
+      end
+
+      it "stringifies" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:to_s).and_return("foobar")
+        expect(dbl.to_s).to eq("foobar")
+      end
+
+      it "returns gibberish" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:to_s).and_return("foo", "bar", "baz")
+        expect(dbl.to_s).to eq("foo")
+        expect(dbl.to_s).to eq("bar")
+        expect(dbl.to_s).to eq("baz")
+        expect(dbl.to_s).to eq("baz")
+      end
+
+      it "returns nil" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:do_something).and_return
+        expect(dbl.do_something).to be_nil
+      end
+    end
+
+    context "and_raise" do
+      double :my_double do
+        stub oops
+      end
+
+      it "raises an error" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:oops).and_raise(DivisionByZeroError.new)
+        expect { dbl.oops }.to raise_error(DivisionByZeroError)
+      end
+      it "raises an error" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:oops).and_raise("Something broke")
+        expect { dbl.oops }.to raise_error(/Something broke/)
+      end
+      it "raises an error" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:oops).and_raise(ArgumentError, "Size must be > 0")
+        expect { dbl.oops }.to raise_error(ArgumentError, /Size/)
+      end
+    end
+
+    context "and_call_original" do
+      class MyType
+        def foo
+          "foo"
+        end
+      end
+
+      mock MyType do
+        stub foo
+      end
+
+      it "calls the original" do
+        instance = MyType.new
+        allow(instance).to receive(:foo).and_call_original
+        expect(instance.foo).to eq("foo")
+      end
+    end
+
+    context "Short-hand for Multiple Stubs" do
+      double :my_double do
+        stub method_a : Symbol
+        stub method_b : Int32
+        stub method_c : String
+      end
+
+      it "does something" do
+        dbl = double(:my_double)
+        allow(dbl).to receive_messages(method_a: :foo, method_b: 42, method_c: "foobar")
+        expect(dbl.method_a).to eq(:foo)
+        expect(dbl.method_b).to eq(42)
+        expect(dbl.method_c).to eq("foobar")
+      end
+    end
+
+    context "Custom Implementation" do
+      double :my_double do
+        stub foo : String
+      end
+
+      it "does something" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:foo) { "foo" }
+        expect(dbl.foo).to eq("foo")
+      end
+    end
+
+    context "Arguments" do
+      double :my_double do
+        stub add(a, b) { a + b }
+        stub do_something(arg) { arg } # Return the argument by default.
+      end
+
+      it "adds two numbers" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:add).and_return(7)
+        expect(dbl.add(1, 2)).to eq(7)
+      end
+
+      it "does basic matching" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:do_something).with(1).and_return(42)
+        allow(dbl).to receive(:do_something).with(2).and_return(22)
+        expect(dbl.do_something(1)).to eq(42)
+        expect(dbl.do_something(2)).to eq(22)
+      end
+
+      it "can call the original" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:do_something).with(1).and_return(42)
+        allow(dbl).to receive(:do_something).with(2).and_call_original
+        expect(dbl.do_something(1)).to eq(42)
+        expect(dbl.do_something(2)).to eq(2)
+      end
+
+      it "falls back to the default" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:do_something).and_return(22)
+        allow(dbl).to receive(:do_something).with(1).and_return(42)
+        expect(dbl.do_something(1)).to eq(42)
+        expect(dbl.do_something(2)).to eq(22)
+        expect(dbl.do_something(3)).to eq(22)
+      end
+
+      it "does advanced matching" do
+        dbl = double(:my_double)
+        allow(dbl).to receive(:do_something).with(Int32).and_return(42)
+        allow(dbl).to receive(:do_something).with(String).and_return("foobar")
+        allow(dbl).to receive(:do_something).with(/hi/).and_return("hello there")
+        expect(dbl.do_something(1)).to eq(42)
+        expect(dbl.do_something("foo")).to eq("foobar")
+        expect(dbl.do_something("hi there")).to eq("hello there")
+      end
+    end
+  end
+end

spec/docs/structure_spec.cr

@@ -0,0 +1,34 @@
+require "../spec_helper"
+
+Spectator.describe String do
+  let(normal_string) { "foobar" }
+  let(empty_string) { "" }
+
+  describe "#empty?" do
+    subject { string.empty? }
+
+    context "when empty" do
+      let(string) { empty_string }
+
+      it "is true" do
+        is_expected.to be_true
+      end
+    end
+
+    context "when not empty" do
+      let(string) { normal_string }
+
+      it "is false" do
+        is_expected.to be_false
+      end
+    end
+  end
+end
+
+Spectator.describe Bytes do
+  it "stores an array of bytes" do
+    bytes = Bytes.new(32)
+    bytes[0] = 42
+    expect(bytes[0]).to eq(42)
+  end
+end

spec/docs/subject_spec.cr

@@ -0,0 +1,32 @@
+require "../spec_helper"
+
+Spectator.describe "subject" do
+  subject(array1) { [1, 2, 3] }
+  subject(array2) { [4, 5, 6] }
+
+  it "has different elements" do
+    expect(array1).to_not eq(subject) # array2 would also work here.
+  end
+
+  let(string) { "foobar" }
+
+  it "isn't empty" do
+    expect(string.empty?).to be_false
+  end
+
+  it "is six characters" do
+    expect(string.size).to eq(6)
+  end
+
+  let(array) { [0, 1, 2] }
+
+  it "modifies the array" do
+    array[0] = 42
+    expect(array).to eq([42, 1, 2])
+  end
+
+  it "doesn't carry across tests" do
+    array[1] = 777
+    expect(array).to eq([0, 777, 2])
+  end
+end