iv-org-mirror/shard-spectator
1
0
Fork 0
mirror of https://gitea.invidious.io/iv-org/shard-spectator.git synced 2024-08-15 00:53:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove or skip mock, double, and stub tests

Browse source
This commit is contained in:
Michael Miller 2022-03-19 17:20:15 -06:00
parent 0c7f72dc78
commit b83c6b7b1e
No known key found for this signature in database
GPG key ID: 32B47AE8F388A1FF
10 changed files with 30 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

32
spec/docs/mocks/mocks_spec.cr
View file

@ -1,32 +0,0 @@
require "../../spec_helper"
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

40
spec/docs/mocks/overview_spec.cr
View file

@ -1,40 +0,0 @@
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

166
spec/docs/mocks/stubs_spec.cr
View file

@ -1,166 +0,0 @@
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