Switch to RSpec

We generally use it in our Ruby code.

Took the time to write some spec descriptions that may help serve as
some documentation as well.

Author: maxjacobson

Diff for: .codeclimate.yml

@@ -13,4 +13,4 @@ ratings:
   paths:
   - "**.rb"
 exclude_paths:
-- test/
+- spec/

Diff for: .rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

Diff for: Gemfile

@@ -1,9 +1,8 @@
 source "https://rubygems.org"
 
-gem "minitest"
-gem "mocha"
+gem "codeclimate-test-reporter", "1.0.0.pre.rc2"
 gem "rake"
+gem "rspec"
 gem "simplecov"
-gem "codeclimate-test-reporter", "1.0.0.pre.rc2"
 
 gemspec

Diff for: Rakefile

@@ -1,11 +1,6 @@
 require "bundler/gem_tasks"
-require "rake/testtask"
+require "rspec/core/rake_task"
 
-Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.ruby_opts = %w[-W0]
-  t.test_files = FileList["test/*_test.rb"]
-  t.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
+task :default => :spec

Diff for: test/locale/en.yml renamed to spec/locale/en.yml

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe Minidoc::Associations do
+  class Cat < Minidoc
+    include Minidoc::Associations
+
+    belongs_to :owner, class_name: "User"
+  end
+
+  class Doggie < Minidoc
+    include Minidoc::Associations
+
+    belongs_to :user
+  end
+
+  module Animal
+    class Armadillo < Minidoc
+      include Minidoc::Associations
+
+      belongs_to :predator
+    end
+
+    class Predator < Minidoc
+    end
+  end
+
+  describe "dynamically defined association methods" do
+    it "can load associated documents" do
+      expect(Cat.new.owner).to be_nil
+      user = User.create
+      cat = Cat.new(owner_id: user.id)
+      expect(cat.owner.id).to eq user.id
+      cat.save
+      expect(cat.owner.id).to eq user.id
+    end
+
+    it "caches the association cache rather than go to the database each time" do
+      user = User.create(name: "Bryan")
+      cat = Cat.create(owner_id: user.id)
+      expect(cat.owner.name).to eq "Bryan"
+      user.set(name: "Noah")
+      expect(cat.owner.name).to eq "Bryan"
+      expect(cat.reload.owner.name).to eq "Noah"
+    end
+
+    it "expires the association cache when a new associated document is provided" do
+      user = User.create(name: "Bryan")
+      cat = Cat.create(owner_id: user.id)
+      expect(cat.owner.name).to eq "Bryan"
+      user.set(name: "Noah")
+      expect(cat.owner.name).to eq "Bryan"
+      cat.owner = user
+      expect(cat.owner.name).to eq "Noah"
+    end
+
+    it "expires the association cache when the related foreign-key id field is updated" do
+      user = User.create(name: "Bryan")
+      cat = Cat.create(owner_id: user.id)
+      expect(cat.owner.name).to eq "Bryan"
+      user.set(name: "Noah")
+      expect(cat.owner.name).to eq "Bryan"
+      cat.owner_id = user.id
+      expect(cat.owner.name).to eq "Noah"
+    end
+  end
+
+  context "when the classes are not namespaced" do
+    it "infers the class name of the association" do
+      expect(Doggie.new.user).to be_nil
+      user = User.create
+      sam = Doggie.new(user_id: user.id)
+      expect(sam.user.id).to eq user.id
+      sam.save
+      expect(sam.user.id).to eq user.id
+    end
+  end
+
+  context "when the classes are namespaced" do
+    it "infers the class name of the association" do
+      expect(Animal::Armadillo.new.predator).to be_nil
+      predator = Animal::Predator.create
+      arnie = Animal::Armadillo.new(predator_id: predator.id)
+      expect(arnie.predator.id).to eq predator.id
+      arnie.save
+      expect(arnie.predator.id).to eq predator.id
+    end
+  end
+end

Diff for: spec/minidoc/associations_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe "connection" do
+  class Company < Minidoc
+    self.collection_name = "accounts"
+  end
+
+  describe ".collection_name" do
+    it "is inferred based on the class name" do
+      expect(User.collection_name).to eq "users"
+    end
+
+    it "can be overridden" do
+      expect(Company.collection_name).to eq "accounts"
+    end
+  end
+
+  describe ".collection" do
+    it "exposes the underlying Mongo object" do
+      expect(User.collection).to be_a Mongo::Collection
+    end
+
+    it "passes through the collection_name to the underlying Mongo::Collection" do
+      expect(User.collection.name).to eq "users"
+      expect(Company.collection.name).to eq "accounts"
+    end
+  end
+
+  describe ".database" do
+    it "exposes the underlying Mongo object" do
+      expect(User.database).to be_a Mongo::DB
+    end
+
+    it "passes through the database name to the underlying Mongo::DB" do
+      expect(User.database.name).to eq "minidoc_test"
+    end
+  end
+
+  describe "first run experience" do
+    it "fails helpfully if you haven't configured the necessary values" do
+      with_alternative_configuration do
+        Minidoc.connection = nil
+        Minidoc.database_name = nil
+        expect { User.create(name: "Kären") }.to raise_error(Minidoc::MissingConfiguration, "Make sure to set Minidoc.connection")
+      end
+    end
+
+    it "fails helpfully if you've only neglected the database_name" do
+      with_alternative_configuration do
+        Minidoc.database_name = nil
+        expect { User.create(name: "Kären") }.to raise_error(Minidoc::MissingConfiguration, "Make sure to set Minidoc.database_name")
+      end
+    end
+  end
+
+  def with_alternative_configuration
+    original_connection = Minidoc.connection
+    original_database_name = Minidoc.database_name
+    yield
+  ensure
+    Minidoc.connection = original_connection
+    Minidoc.database_name = original_database_name
+  end
+end

Diff for: spec/minidoc/connection_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Minidoc::Counters do
+  class SimpleCounter < Minidoc
+    include Minidoc::Counters
+
+    counter :counter
+  end
+
+  class AdvancedCounter < Minidoc
+    include Minidoc::Counters
+
+    counter :counter, start: 2, step_size: 3
+  end
+
+  describe "#increment_counter" do
+    it "increments the field" do
+      x = SimpleCounter.create!
+      expect(x.counter).to eq 0
+      expect(x.increment_counter).to eq 1
+      expect(x.increment_counter).to eq 2
+      expect(x.increment_counter).to eq 3
+      expect(x.reload.counter).to eq 3
+    end
+
+    it "can be customized with some options" do
+      x = AdvancedCounter.create!
+      expect(x.counter).to eq 2
+      expect(x.increment_counter).to eq 5
+      expect(x.increment_counter).to eq 8
+      expect(x.increment_counter).to eq 11
+      expect(x.reload.counter).to eq 11
+    end
+
+    it "is thread safe" do
+      x = SimpleCounter.create!
+      counters = []
+      [Thread.new { 5.times { (counters << x.increment_counter) } }, Thread.new { 5.times { (counters << x.increment_counter) } }, Thread.new { 5.times { (counters << x.increment_counter) } }].map(&:join)
+      expect(counters.uniq.length).to eq 15
+    end
+  end
+end

Diff for: spec/minidoc/counters_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Minidoc::Finders do
+  describe ".all" do
+    it "returns all of the documents in the collection" do
+      (User.collection << { name: "Joe" })
+      (User.collection << { name: "Bryan" })
+      users = User.all
+      expect(["Bryan", "Joe"]).to match_array(users.map(&:name))
+    end
+  end
+
+  describe ".count" do
+    it "counts the documents in the collection" do
+      (User.collection << { name: "Joe" })
+      (User.collection << { name: "Bryan" })
+      expect(User.count).to eq 2
+    end
+
+    it "can be scoped by a query" do
+      (User.collection << { name: "Joe" })
+      (User.collection << { name: "Bryan" })
+      expect(User.count(name: "Bryan")).to eq 1
+    end
+  end
+
+  describe ".exists?" do
+    it "tells you if any documents exist that match a query" do
+      (User.collection << { name: "Joe" })
+      expect(User.exists?(name: "Joe")).to be(true)
+      expect(User.exists?(name: "Bryan")).to be(false)
+    end
+  end
+
+  describe ".first" do
+    it "returns a document from the collection" do
+      expect(User.first).to be_nil
+      user = User.create(name: "Bryan")
+      expect(User.first.name).to eq "Bryan"
+      expect(User.first).to eq user
+    end
+  end
+
+  describe ".find" do
+    it "querys the collection using the mongodb query language" do
+      user = User.create(name: "Bryan")
+      expect(User.find({}).to_a).to eq [user]
+      expect(User.find(name: "Noah").to_a).to eq []
+    end
+  end
+
+  describe ".find_one" do
+    it "returns the first document that matches a query" do
+      user = User.create(name: "Bryan")
+      expect(User.find_one({})).to eq user
+      expect(User.find_one(name: "Noah")).to eq nil
+    end
+  end
+
+  describe ".find_one!" do
+    it "returns the first document that matches a query or raises an error" do
+      user = User.create(name: "Bryan")
+      expect(User.find_one!(name: "Bryan")).to eq user
+      expect { User.find_one!(name: "Noah") }.to raise_error(Minidoc::DocumentNotFoundError)
+    end
+  end
+
+  describe ".find_one_or_initialize" do
+    it "returns the first document that matches a query or makes a non-persisted document from that query" do
+      user = User.create(name: "Bryan", age: 1)
+      expect((user == User.find_one_or_initialize(name: "Bryan"))).to be_truthy
+      expect(User.find_one_or_initialize(name: "Noah").is_a?(User)).to eq true
+      expect(User.find_one_or_initialize(name: "Noah").new_record?).to eq true
+    end
+
+    it "allows query options" do
+      user = User.create(name: "Noah", age: 1)
+      expect((user == User.find_one_or_initialize({ age: 1 }, sort: { name: -1 }))).to be_truthy
+      expect { User.find_one_or_initialize("foo") }.to raise_error(ArgumentError)
+    end
+  end
+end

Diff for: spec/minidoc/finders_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Minidoc::Grid do
+  let(:grid) { Minidoc::Grid.new(Minidoc.database) }
+
+  describe "#put and #get" do
+    it "can store raw string data" do
+      doc_id = grid.put "estamos en espana"
+      expect(doc_id).to be_a BSON::ObjectId
+
+      document = grid.get doc_id.to_s
+
+      expect(document).to be_a Mongo::GridIO
+      expect(document.read).to eq "estamos en espana"
+    end
+  end
+
+  describe "#get_json" do
+    it "parses the JSON into structured ruby objects" do
+      hash = { "foo" => { "bar" => 1 } }
+      doc_id = grid.put(hash.to_json)
+
+      value = grid.get_json(doc_id.to_s)
+
+      expect(value).to eq hash
+    end
+  end
+
+  describe "#delete" do
+    it "removes the 'file' from the database" do
+      doc_id = grid.put "estamos en espana"
+
+      grid.delete doc_id.to_s
+
+      expect { grid.get doc_id }.to raise_error(Mongo::GridFileNotFound)
+    end
+  end
+end

Diff for: spec/minidoc/grid_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Minidoc::ReadOnly do
+  class ReadOnlyUser < Minidoc::ReadOnly
+    self.collection_name = "users"
+    attribute :name, String
+  end
+
+  it "is read only, meaning it can't change over time" do
+    expect { ReadOnlyUser.create(name: "Bryan") }.to raise_error(NoMethodError)
+
+    rw_user = User.create(name: "Bryan")
+    user = ReadOnlyUser.first
+    expect(user.name).to eq "Bryan"
+    expect(rw_user.id).to eq user.id
+    expect(user).to eq user.as_value
+
+    expect { user.name = "Noah" }.to raise_error(NoMethodError)
+  end
+
+  it "can become a value object" do
+    user = User.new(name: "Bryan")
+    user.name = "Noah"
+    user = user.as_value
+
+    expect { user.name = "Noah" }.to raise_error(NoMethodError)
+  end
+end