calendarium-romanum 0.2.1 → 0.7.0

data/spec/readme_spec.rb

@@ -34,16 +34,24 @@ class MarkdownDocument
   end
 end
 
-describe 'README.md' do
-  readme_path = File.expand_path('../../README.md', __FILE__)
-  readme = File.read readme_path
-  doc = MarkdownDocument.new readme
-
-  doc.each_ruby_example do |code, line|
-    describe "example L#{line}" do
-      it 'executes without failure' do
-        cls = Class.new
-        cls.class_eval(code, readme_path, line)
+%w(README.md data/README.md).each do |path|
+  describe path do
+    before :each do
+      # README examples sometimes print, but we don't want them
+      # to distort test output
+      allow(STDERR).to receive :puts
+    end
+
+    readme_path = File.expand_path('../../' + path, __FILE__)
+    readme = File.read readme_path
+    doc = MarkdownDocument.new readme
+
+    doc.each_ruby_example do |code, line|
+      describe "example L#{line}" do
+        it 'executes without failure' do
+          cls = Class.new
+          cls.class_eval(code, readme_path, line)
+        end
       end
     end
   end

data/spec/sanctorale_factory_spec.rb

@@ -2,18 +2,100 @@
 require 'spec_helper'
 
 describe CR::SanctoraleFactory do
-  describe '.create_layered'
+  describe '.create_layered' do
+    describe 'metadata handling' do
+      let(:metadata_a) { {'title' => 'Calendar', 'foo' => 'bar'} }
+      let(:metadata_b) { {'title' => 'Second calendar', 'some' => 'handsome', 'extends' => ['with_a']} }
+      let(:metadata_nonhash) { [:something] }
+      let(:with_a) { CR::Sanctorale.new.tap {|s| s.metadata = metadata_a }}
+      let(:with_b) { CR::Sanctorale.new.tap {|s| s.metadata = metadata_b } }
+      let(:without) { CR::Sanctorale.new }
+      let(:with_nonhash) { CR::Sanctorale.new.tap {|s| s.metadata = metadata_nonhash } }
 
-  describe '.load_layered_from_files' do
-    before :each do
-      files = %w(czech-cs.txt czech-cechy-cs.txt czech-budejovice-cs.txt).collect do |f|
-        File.join(File.expand_path('../data', File.dirname(__FILE__)), f)
+      it 'creates merged metadata' do
+        merged = {
+          # conflicting key - later wins
+          'title' => 'Second calendar',
+          # non-conflicting key from the first
+          'foo' => 'bar',
+          # non-conflicting key from the second
+          'some' => 'handsome',
+        }
+
+        result = described_class.create_layered(with_a, with_b)
+
+        expect(merged).to be < result.metadata
+
+        # key 'extends' has special meaning and is therefore
+        # always deleted from merged metadata
+        expect(result.metadata).not_to have_key 'extends'
+      end
+
+      it 'stores original metadata' do
+        result = described_class.create_layered(with_a, with_b)
+        expect(result.metadata['components'])
+          .to eq [metadata_a, metadata_b]
+      end
+
+      it 'overwrites key "components" if it exists' do
+        result = described_class.create_layered(
+          with_a,
+          # this calendar's metadata have key 'components',
+          # but that key is special and we always set it's contents
+          # when merging
+          CR::Sanctorale.new.tap {|s| s.metadata = {'components' => :c} }
+        )
+        expect(result.metadata['components'])
+          .to eq [metadata_a, {'components' => :c}]
+      end
+
+      it 'copes with nil metadata on the first place' do
+        result = described_class.create_layered(without, with_a)
+
+        expect(metadata_a).to be < result.metadata
+        expect(result.metadata['components'])
+          .to eq [nil, metadata_a] # nils are preserved in 'components'
+      end
+
+      it 'copes with nil metadata on the last place' do
+        result = described_class.create_layered(with_a, without)
+
+        expect(metadata_a).to be < result.metadata
+        expect(result.metadata['components'])
+          .to eq [metadata_a, nil]
+      end
+
+      it 'copes with all nil' do
+        result = described_class.create_layered(without, without)
+
+        expect(result.metadata['components'])
+          .to eq [nil, nil]
+      end
+
+      it 'copes with non-Hash metadata' do
+        result = described_class.create_layered(
+          with_a,
+          with_nonhash
+        )
+        # non-Hash metadata are not merged, but they do appear
+        # in 'components'
+        expect(metadata_a).to be < result.metadata
+        expect(result.metadata['components'])
+          .to eq [metadata_a, metadata_nonhash]
+      end
+
+      it 'copes with all non-Hash' do
+        result = described_class.create_layered(with_nonhash)
+
+        expect(result.metadata['components'])
+          .to eq [metadata_nonhash]
       end
-      @s = described_class.load_layered_from_files(*files)
     end
+  end
 
+  shared_examples 'calendar layering České Budějovice' do
     it 'has celebrations from the first file' do
-      dd = @s.get 9, 28
+      dd = layered_sanctorale.get 9, 28
       expect(dd.size).to eq 1
 
       d = dd.first
@@ -22,7 +104,7 @@ describe CR::SanctoraleFactory do
     end
 
     it 'has celebrations from the second file' do
-      dd = @s.get 7, 4
+      dd = layered_sanctorale.get 7, 4
       expect(dd.size).to eq 1
 
       d = dd.first
@@ -31,7 +113,7 @@ describe CR::SanctoraleFactory do
     end
 
     it 'celebrations from the last file win' do
-      dd = @s.get 12, 22
+      dd = layered_sanctorale.get 12, 22
       expect(dd.size).to eq 1
 
       d = dd.first
@@ -39,4 +121,26 @@ describe CR::SanctoraleFactory do
       expect(d.title).to eq 'Výročí posvěcení katedrály sv. Mikuláše'
     end
   end
+
+  describe '.load_layered_from_files' do
+    let(:layered_sanctorale) do
+      files = %w(czech-cs.txt czech-cechy-cs.txt czech-budejovice-cs.txt).collect do |f|
+        File.join(File.expand_path('../data', File.dirname(__FILE__)), f)
+      end
+
+      described_class.load_layered_from_files(*files)
+    end
+
+    include_examples 'calendar layering České Budějovice'
+  end
+
+  describe '.load_with_parents' do
+    let(:layered_sanctorale) do
+      path = File.join(File.expand_path('../data', File.dirname(__FILE__)), 'czech-budejovice-cs.txt')
+
+      described_class.load_with_parents path
+    end
+
+    include_examples 'calendar layering České Budějovice'
+  end
 end

data/spec/sanctorale_loader_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe CR::SanctoraleLoader do
+  let(:s) { CR::Sanctorale.new }
+  let(:l) { CR::SanctoraleLoader.new }
+
+  describe 'data sources' do
+    describe '#load_from_string' do
+      before :each do
+        str = '1/3 : Ss.mi Nominis Iesu'
+        l.load_from_string str, s
+      end
+
+      it 'loads one entry' do
+        expect(s.size).to eq 1
+      end
+    end
+
+    describe '#load_from_file' do
+      it 'loads something from file' do
+        l.load_from_file(File.join(%w(data universal-la.txt)), s)
+        expect(s.size).to be > 190
+      end
+    end
+  end
+
+  describe 'record/file format' do
+    let(:record) { '4/25 f R :  S. Marci, evangelistae' }
+    let(:result) { l.send :load_line, record }
+
+    describe 'title' do
+      it 'loads it' do
+        expect(result.title).to eq 'S. Marci, evangelistae'
+      end
+    end
+
+    describe 'date' do
+      describe 'full date as part of the record' do
+        it 'loads date' do
+          expect(result.date).to eq CR::AbstractDate.new(4, 25)
+        end
+      end
+
+      describe 'month as heading' do
+        before :each do
+          str = [
+            # month heading + day-only record
+            '= 1',
+            '25 f : In conversione S. Pauli, apostoli',
+            # record with full date specified
+            '4/25 f r :  S. Marci, evangelistae',
+          ].join "\n"
+          l.load_from_string str, s
+        end
+
+        it 'loads a month heading and uses the month for subsequent records' do
+          expect(s.get(1, 25)).not_to be_empty
+        end
+
+        it 'still allows full date specified in the record' do
+          expect(s.get(4, 25)).not_to be_empty
+        end
+      end
+    end
+
+    describe 'colour' do
+      describe 'not specified - sets default' do
+        let(:record) { '4/25 :  S. Marci, evangelistae' }
+        it { expect(result.colour).to eq CR::Colours::WHITE }
+      end
+
+      describe 'sets colour if specified' do
+        let(:record) { '4/25 f R :  S. Marci, evangelistae' }
+        it { expect(result.colour).to eq CR::Colours::RED }
+      end
+
+      describe 'sets colour if specified (lowercase)' do
+        let(:record) { '4/25 f r :  S. Marci, evangelistae' }
+        it { expect(result.colour).to eq CR::Colours::RED }
+      end
+    end
+
+    describe 'rank' do
+      # say we specify a proper calendar of a church dedicated to St. George
+      describe 'not specified - sets default' do
+        let(:record) { '4/23 : S. Georgii, martyris' }
+        it { expect(result.rank).to eq CR::Ranks::MEMORIAL_OPTIONAL }
+      end
+
+      describe 'sets rank if specified' do
+        let(:record) { '4/23 s R : S. Georgii, martyris' }
+        it { expect(result.rank).to eq CR::Ranks::SOLEMNITY_GENERAL }
+      end
+
+      describe 'sets rank if specified (uppercase)' do
+        let(:record) { '4/23 S R : S. Georgii, martyris' }
+        it { expect(result.rank).to eq CR::Ranks::SOLEMNITY_GENERAL }
+      end
+
+      describe 'sets exact rank if specified' do
+        let(:record) { '4/23 s1.4 R : S. Georgii, martyris' }
+        it { expect(result.rank).to eq CR::Ranks::SOLEMNITY_PROPER }
+      end
+
+      describe 'sets exact rank if specified only by number' do
+        let(:record) { '4/23 1.4 R : S. Georgii, martyris' }
+        it { expect(result.rank).to eq CR::Ranks::SOLEMNITY_PROPER }
+      end
+    end
+
+    describe 'symbol' do
+      describe 'not specified - sets default' do
+        let(:record) { '4/23 : S. Georgii, martyris' }
+        it { expect(result.symbol).to be nil }
+      end
+
+      describe 'specified - uses it' do
+        let(:record) { '4/23 george : S. Georgii, martyris' }
+        it { expect(result.symbol).to be :george }
+      end
+
+      describe 'supported characters' do
+        let(:record) { '4/29 none_123 : S. Nullius, abbatis' }
+        it { expect(result.symbol).to be :none_123 }
+      end
+    end
+  end
+
+  describe 'Celebration properties set regardless of the loaded data' do
+    describe 'cycle' do
+      it 'always sets it to :sanctorale' do
+        str = '4/23 1.4 R : S. Georgii, martyris'
+        record = l.send :load_line, str
+        expect(record.cycle).to be :sanctorale
+      end
+    end
+  end
+
+  describe 'invalid input' do
+    describe 'syntax errors' do
+      it 'invalid syntax' do
+        str = 'line without standard beginning'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Syntax error/)
+      end
+    end
+
+    describe 'syntactically correct data making no sense' do
+      it 'invalid month heading' do
+        str = '= 13'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Invalid month/)
+      end
+
+      it 'one more invalid month heading' do
+        str = '= 0'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Invalid month/)
+      end
+
+      it 'invalid month' do
+        str = '100/25 f : In conversione S. Pauli, apostoli'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Invalid month/)
+      end
+
+      it 'line with day only, without preceding month heading' do
+        str = '25 f : In conversione S. Pauli, apostoli'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Invalid month/)
+      end
+
+      it 'invalid day' do
+        str = '1/250 f : In conversione S. Pauli, apostoli'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Invalid day/)
+      end
+
+      it 'invalid rank' do
+        str = '1/25 X : In conversione S. Pauli, apostoli'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /Syntax error/)
+      end
+
+      it 'invalid numeric rank' do
+        str = '4/23 s8.4 R : S. Georgii, martyris'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /rank/)
+      end
+
+      it 'invalid combination of rank latter and number' do
+        str = '4/23 m2.5 R : S. Georgii, martyris'
+        expect do
+          l.load_from_string str, s
+        end.to raise_exception(CR::InvalidDataError, /rank/)
+      end
+    end
+  end
+
+  describe 'YAML front matter (YFM)' do
+    it 'sets metadata nil if YFM is not provided' do
+      expect(l.load_from_string('').metadata)
+        .to be nil
+    end
+
+    it 'loads metadata if provided' do
+      expect(l.load_from_string("---\nkey: value\n---").metadata)
+        .to eq({'key' => 'value'})
+    end
+
+    it 'does not load metadata with no end' do
+      # Since YFM is being processed on encountering the closing
+      # triple-dash, YFM spanning the whole file and not properly
+      # closed will not be loaded.
+      # (Implementation detail and crazy edge case, may change
+      # in future without warning.)
+      expect(l.load_from_string("---\nkey: value").metadata)
+        .to be nil
+    end
+  end
+end

data/spec/sanctorale_spec.rb

@@ -1,167 +1,281 @@
 require 'spec_helper'
 
 describe CR::Sanctorale do
-  before :each do
-    @s = described_class.new
-  end
+  let(:s) { described_class.new }
+
+  # example celebrations
+  let(:antonius) { CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL, CR::Colours::WHITE, :antonius) }
+  let(:nullus) { CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_OPTIONAL, CR::Colours::WHITE, :nullus) }
+  let(:ignotus) { CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_OPTIONAL, CR::Colours::WHITE, :ignotus) }
+  let(:opt_memorial) { nullus }
+  let(:opt_memorial_2) { ignotus }
+  let(:solemnity) { CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_PROPER, CR::Colours::WHITE, :nullus_solemnity) }
 
   describe '#get' do
-    describe 'for empty day' do
+    describe 'for an empty day' do
       it 'returns an Array' do
-        expect(@s.get(1,3)).to be_an Array
+        expect(s.get(1, 3)).to be_an Array
       end
     end
 
-    describe 'for unempty day' do
+    describe 'for an unempty day' do
       before :each do
-        @c = CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
-        @s.add 1, 17, @c
+        s.add 1, 17, antonius
       end
 
       it 'get by month, day' do
-        expect(@s.get(1, 17)).to eq [@c]
+        expect(s.get(1, 17)).to eq [antonius]
       end
 
       it 'get by Date' do
-        expect(@s.get(Date.new(2014, 1, 17))).to eq [@c]
+        expect(s.get(Date.new(2014, 1, 17))).to eq [antonius]
       end
 
       it 'may have more CR::Celebrations for a day' do
         [
-         'S. Fabiani, papae et martyris',
-         'S. Sebastiani, martyris'
-        ].each {|t| @s.add 1, 20, CR::Celebration.new(t, CR::Ranks::MEMORIAL_OPTIONAL) }
-        expect(@s.get(1, 20).size).to eq 2
+          'S. Fabiani, papae et martyris',
+          'S. Sebastiani, martyris'
+        ].each {|t| s.add 1, 20, CR::Celebration.new(t, CR::Ranks::MEMORIAL_OPTIONAL) }
+        expect(s.get(1, 20).size).to eq 2
       end
     end
   end
 
   describe '#add' do
     it 'adds a CR::Celebration to one month only' do
-      @s.add 1, 17, CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
-      expect(@s.get(2, 17)).to be_empty
+      s.add 1, 17, antonius
+      expect(s.get(2, 17)).to be_empty
     end
 
     it 'does not allow month 0' do
-      expect { @s.add 0, 1, CR::Celebration.new('S. Nullius') }.to raise_exception RangeError
+      expect { s.add 0, 1, opt_memorial }.to raise_exception RangeError
     end
 
     it 'does not allow month higher than 12' do
-      expect { @s.add 13, 1, CR::Celebration.new('S. Nullius') }.to raise_exception RangeError
+      expect { s.add 13, 1, opt_memorial }.to raise_exception RangeError
     end
 
     it 'adds solemnity to a dedicated container' do
-      expect { @s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_PROPER) }.to change { @s.solemnities.size }.by 1
+      expect { s.add 1, 13, solemnity }.to change { s.solemnities.size }.by 1
     end
 
     it 'does not add non-solemnity to solemnities' do
-      expect { @s.add 1, 13, CR::Celebration.new('S. Nullius') }.not_to change { @s.solemnities.size }
+      expect { s.add 1, 13, opt_memorial }.not_to change { s.solemnities.size }
+    end
+
+    it 'fails when adding second celebration with the same symbol' do
+      s.add 1, 13, antonius
+
+      expect do
+        s.add 1, 14, antonius
+      end.to raise_exception ArgumentError, /duplicate symbol :antonius/
     end
 
     describe 'multiple celebrations on a single day' do
       it 'succeeds for any number of optional memorials' do
+        s.add 1, 13, opt_memorial
+
         expect do
-          @s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_OPTIONAL)
-          @s.add 1, 13, CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_OPTIONAL)
+          s.add 1, 13, opt_memorial_2
         end.not_to raise_exception
       end
 
       it 'fails when adding a non-optional memorial' do
+        s.add 1, 13, opt_memorial
+
         expect do
-          @s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_OPTIONAL)
-          @s.add 1, 13, CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_GENERAL)
+          s.add 1, 13, CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_GENERAL)
         end.to raise_exception ArgumentError
       end
 
       it 'fails when adding to a non-optional memorial' do
+        s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_GENERAL)
+
         expect do
-          @s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::MEMORIAL_GENERAL)
-          @s.add 1, 13, CR::Celebration.new('S. Ignoti', CR::Ranks::MEMORIAL_OPTIONAL)
+          s.add 1, 13, opt_memorial_2
         end.to raise_exception ArgumentError
       end
+
+      # there used to be a bug, registering a solemnity *before*
+      # checking if it can be added at all
+      it 'does not modify internal state when it fails' do
+        s.add 1, 13, opt_memorial
+
+        expect do
+          begin
+            s.add 1, 13, CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_GENERAL)
+          rescue ArgumentError
+          end
+        end.not_to change { s.solemnities.size }
+      end
     end
   end
 
   describe '#replace' do
     it 'replaces the original celebration(s)' do
-      nemo = CR::Celebration.new('S. Nullius')
-      nonus = CR::Celebration.new('S. Noni', CR::Ranks::SOLEMNITY_PROPER)
-
-      @s.add 1, 13, nemo
-      @s.replace 1, 13, [nonus]
+      s.add 1, 13, opt_memorial_2
+      s.replace 1, 13, [solemnity]
 
-      expect(@s.get(1, 13)).to eq [nonus]
+      expect(s.get(1, 13)).to eq [solemnity]
     end
 
     it 'adds solemnity to a dedicated container' do
-      nonus = CR::Celebration.new('S. Noni', CR::Ranks::SOLEMNITY_PROPER)
       expect do
-        @s.replace 1, 13, [nonus]
-      end.to change { @s.solemnities.size }.by 1
+        s.replace 1, 13, [solemnity]
+      end.to change { s.solemnities.size }.by 1
     end
 
     it 'removes solemnity' do
-      nemo = CR::Celebration.new('S. Nullius', CR::Ranks::SOLEMNITY_PROPER)
-      nonus = CR::Celebration.new('S. Noni')
-
-      @s.add 1, 13, nemo
+      s.add 1, 13, solemnity
       expect do
-        @s.replace 1, 13, [nonus]
-      end.to change { @s.solemnities.size }.by -1
+        s.replace 1, 13, [opt_memorial_2]
+      end.to change { s.solemnities.size }.by(-1)
+    end
+
+    it 'does not simply save the passed Array' do
+      array = [opt_memorial]
+      s.replace 1, 13, array
+
+      array << nil
+
+      expect(s.get(1, 13)).not_to include nil
+    end
+
+    describe 'duplicate symbol handling' do
+      it 'fails when adding second celebration with the same symbol' do
+        s.replace 1, 13, [nullus]
+
+        expect do
+          s.replace 1, 14, [nullus]
+        end.to raise_exception ArgumentError, /duplicate symbols \[:nullus\]/
+      end
+
+      it 'failed attempts do not modify state of the internal symbol set' do
+        s.replace 1, 14, [nullus]
+        s.replace 1, 15, [ignotus]
+
+        expect do
+          s.replace 1, 14, [ignotus]
+        end.to raise_exception ArgumentError, /duplicate symbols \[:ignotus\]/
+
+        expect do
+          s.replace 1, 15, [nullus]
+        end.to raise_exception ArgumentError, /duplicate symbols \[:nullus\]/
+      end
+
+      it 'succeeds when celebration with the same symbol is being replaced' do
+        s.replace 1, 13, [nullus]
+
+        expect do
+          s.replace 1, 13, [nullus]
+        end.not_to raise_exception
+      end
     end
   end
 
   describe '#update' do
-    before :each do
-      @s2 = described_class.new
-    end
+    let(:s2) { described_class.new }
 
     it 'adds entries from the argument to receiver' do
-      @s2.add 1, 17, CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
+      s2.add 1, 17, antonius
 
-      expect(@s).to be_empty
-      @s.update @s2
-      expect(@s.size).to eq 1
+      expect(s).to be_empty
+      s.update s2
+      expect(s.size).to eq 1
     end
 
     it 'overwrites eventual previous content of the day' do
-      @s.add 1, 17, CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
-      cele = CR::Celebration.new('S. Nulius, monachi')
-      @s2.add 1, 17, cele
+      s.add 1, 17, antonius
+      s2.add 1, 17, opt_memorial
+
+      s.update s2
+      expect(s.get(1, 17)).to eq [opt_memorial]
+    end
+
+    it 'does not overwrite content of days for which it does not have any' do
+      s.add 1, 17, antonius
 
-      @s.update @s2
-      expect(@s.get(1, 17)).to eq [cele]
+      s.update s2
+      expect(s.get(1, 17)).to eq [antonius]
     end
   end
 
   describe '#size' do
     it 'knows when the Sanctorale is empty' do
-      expect(@s.size).to eq 0
+      expect(s.size).to eq 0
     end
 
     it 'knows when there is something' do
-      @s.add 1, 17, CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
-      expect(@s.size).to eq 1
+      s.add 1, 17, antonius
+      expect(s.size).to eq 1
     end
   end
 
   describe '#empty?' do
     it 'is empty at the beginning' do
-      expect(@s).to be_empty
+      expect(s).to be_empty
     end
 
     it 'is never more empty once a record is entered' do
-      @s.add 1, 17, CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
-      expect(@s).not_to be_empty
+      s.add 1, 17, antonius
+      expect(s).not_to be_empty
     end
   end
 
   describe '#each_day' do
+    before :each do
+      s.add 1, 17, antonius
+    end
+
     it 'yields each date and corresponding CR::Celebrations' do
-      cele = CR::Celebration.new('S. Antonii, abbatis', CR::Ranks::MEMORIAL_GENERAL)
-      @s.add 1, 17, cele
+      expect {|block| s.each_day(&block) }.to yield_with_args(CR::AbstractDate.new(1, 17), [antonius])
+    end
 
-      expect {|block| @s.each_day(&block) }.to yield_with_args(CR::AbstractDate.new(1, 17), [cele])
+    it 'can be called without a block' do
+      expect(s.each_day).to be_an Enumerator
+    end
+  end
+
+  describe '#freeze' do
+    it 'makes the instance frozen' do
+      expect(s).not_to be_frozen # make sure
+      s.freeze
+      expect(s).to be_frozen
+    end
+
+    it 'prevents modification' do
+      s.freeze
+
+      expect do
+        s.add 1, 17, antonius
+      end.to raise_exception(RuntimeError, /can't modify frozen/)
+    end
+  end
+
+  describe '#==' do
+    describe 'empty' do
+      it 'is equal' do
+        expect(described_class.new).to be == described_class.new
+      end
+    end
+
+    describe 'with content' do
+      let(:a) do
+        s = described_class.new
+        s.add 1, 17, antonius
+        s
+      end
+
+      it 'different' do
+        expect(a).not_to be == described_class.new
+      end
+
+      it 'same' do
+        b = described_class.new
+        b.add 1, 17, antonius
+
+        expect(a).to be == b
+      end
     end
   end
 end