masamune 0.11.0

data/spec/masamune/data_plan/engine_spec.rb

@@ -0,0 +1,356 @@
+#  The MIT License (MIT)
+#
+#  Copyright (c) 2014-2015, VMware, Inc. All Rights Reserved.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+
+require 'spec_helper'
+
+describe Masamune::DataPlan::Engine do
+  let(:filesystem) { Masamune::MockFilesystem.new }
+  let(:environment) { Masamune::Environment.new }
+  let(:engine) { Masamune::DataPlan::Engine.new }
+
+  before do
+    environment.filesystem = filesystem
+    engine.environment = environment
+  end
+
+  let(:command) do
+    Proc.new do |engine, rule|
+      missing_targets = []
+      engine.targets(rule).missing.each do |target|
+        missing_targets << target.path if target.sources.existing.any?
+      end
+      engine.filesystem.touch!(*missing_targets.map { |target| File.join(target, 'DATA') }) if missing_targets.any?
+    end
+  end
+
+  before do
+    engine.add_target_rule('non_primary', path: '/table/y=%Y/m=%m/d=%d', primary: false)
+    engine.add_source_rule('non_primary', path: '/log/%Y%m%d.*.log', primary: false)
+    engine.add_command_rule('non_primary', ->(*_) { fail } )
+    engine.add_target_rule('primary', path: '/table/y=%Y/m=%m/d=%d')
+    engine.add_source_rule('primary', path: '/log/%Y%m%d.*.log')
+    engine.add_command_rule('primary', command)
+    engine.add_target_rule('derived_daily', path: '/daily/%Y-%m-%d')
+    engine.add_source_rule('derived_daily', path: '/table/y=%Y/m=%m/d=%d')
+    engine.add_command_rule('derived_daily', command)
+    engine.add_target_rule('derived_monthly', path: '/monthly/%Y-%m')
+    engine.add_source_rule('derived_monthly', path: '/table/y=%Y/m=%m/d=%d')
+    engine.add_command_rule('derived_monthly', command)
+  end
+
+  describe '#filesystem' do
+    it { expect(engine.filesystem).to be_a(Masamune::CachedFilesystem) }
+    it { expect(environment.filesystem).to be_a(Masamune::MockFilesystem) }
+  end
+
+  describe '#targets_for_date_range' do
+    let(:start) { Date.civil(2013,01,01) }
+    let(:stop) { Date.civil(2013,01,03) }
+
+    subject { engine.targets_for_date_range(rule, start, stop).map(&:path) }
+
+    context 'primary' do
+      let(:rule) { 'primary' }
+      it { is_expected.to include '/table/y=2013/m=01/d=01' }
+      it { is_expected.to include '/table/y=2013/m=01/d=02' }
+      it { is_expected.to include '/table/y=2013/m=01/d=03' }
+      it 'has 3 items' do
+        expect(subject.size).to eq(3)
+      end
+    end
+
+    context 'derived_daily' do
+      let(:rule) { 'derived_daily' }
+      it { is_expected.to include '/daily/2013-01-01' }
+      it { is_expected.to include '/daily/2013-01-02' }
+      it { is_expected.to include '/daily/2013-01-03' }
+      it 'has 3 items' do
+        expect(subject.size).to eq(3)
+      end
+    end
+
+    context 'derived_monthly' do
+      let(:rule) { 'derived_monthly' }
+      it { is_expected.to include '/monthly/2013-01' }
+      it 'has 1 item' do
+        expect(subject.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#targets_for_source' do
+    subject(:targets) do
+      engine.targets_for_source(rule, source)
+    end
+
+    context 'primary' do
+      let(:rule) { 'primary' }
+      let(:source) { '/log/20130101.random.log' }
+
+      it { expect(targets.first.start_time).to eq(Date.civil(2013,01,01)) }
+      it { expect(targets.first.stop_time).to eq(Date.civil(2013,01,02)) }
+      it { expect(targets.first.path).to eq('/table/y=2013/m=01/d=01') }
+    end
+
+    context 'derived_daily' do
+      let(:rule) { 'derived_daily' }
+      let(:source)  { '/table/y=2013/m=01/d=01' }
+
+      it { expect(targets.first.start_time).to eq(Date.civil(2013,01,01)) }
+      it { expect(targets.first.stop_time).to eq(Date.civil(2013,01,02)) }
+      it { expect(targets.first.path).to eq('/daily/2013-01-01') }
+    end
+
+    context 'derived_monthly' do
+      let(:rule) { 'derived_monthly' }
+      let(:source)  { '/table/y=2013/m=01/d=01' }
+
+      it { expect(targets.first.start_time).to eq(Date.civil(2013,01,01)) }
+      it { expect(targets.first.stop_time).to eq(Date.civil(2013,02,01)) }
+      it { expect(targets.first.path).to eq('/monthly/2013-01') }
+    end
+  end
+
+  describe '#sources_for_target' do
+    subject(:sources) do
+      engine.sources_for_target(rule, target)
+    end
+
+    subject(:existing) do
+      sources.existing
+    end
+
+    before do
+      engine.filesystem.touch!('/log/20130101.app1.log')
+      engine.filesystem.touch!('/log/20130101.app2.log')
+      engine.filesystem.touch!('/log/20130104.app1.log')
+      engine.filesystem.touch!('/log/20130104.app2.log')
+    end
+
+    context 'valid target associated with wildcard source' do
+      let(:rule) { 'primary' }
+      let(:target) { '/table/y=2013/m=01/d=01' }
+
+      it { expect(sources.size).to eq(1) }
+      it { expect(sources).to include '/log/20130101.*.log' }
+      it { expect(existing.size).to eq(2) }
+      it { expect(existing).to include '/log/20130101.app1.log' }
+      it { expect(existing).to include '/log/20130101.app2.log' }
+    end
+
+    context 'valid target associated with a single source file' do
+      let(:rule) { 'derived_daily' }
+      let(:target) { '/daily/2013-01-03' }
+
+      it { expect(sources).to include '/table/y=2013/m=01/d=03' }
+    end
+
+    context 'valid target associated with a group of source files' do
+      let(:rule) { 'derived_monthly' }
+      let(:target) { '/monthly/2013-01' }
+
+      (1..31).each do |day|
+        it { expect(sources).to include '/table/y=2013/m=01/d=%02d' % day }
+      end
+      it { expect(sources.size).to eq(31) }
+    end
+
+    context 'invalid target' do
+      let(:rule) { 'derived_daily' }
+      let(:target) {  '/table/y=2013/m=01/d=01' }
+      it { expect { subject }.to raise_error }
+    end
+  end
+
+  describe '#rule_for_target' do
+    subject { engine.rule_for_target(target) }
+
+    context 'primary source' do
+      let(:target) { '/log/20130101.random_1.log' }
+      it { is_expected.to eq(Masamune::DataPlan::Rule::TERMINAL) }
+    end
+
+    context 'primary target' do
+      let(:target) { '/table/y=2013/m=01/d=01' }
+      it { is_expected.to eq('primary') }
+    end
+
+    context 'derived_daily target' do
+      let(:target) { '/daily/2013-01-03' }
+      it { is_expected.to eq('derived_daily') }
+    end
+
+    context 'derived_monthly target' do
+      let(:target) { '/monthly/2013-01' }
+      it { is_expected.to eq('derived_monthly') }
+    end
+
+    context 'invalid target' do
+      let(:target) { '/daily' }
+      it { expect { subject }.to raise_error }
+    end
+  end
+
+  describe '#prepare' do
+    before do
+      engine.prepare(rule, options)
+    end
+
+    subject(:targets) do
+      engine.targets(rule)
+    end
+
+    subject(:sources) do
+      engine.sources(rule)
+    end
+
+    context 'with :targets' do
+      let(:rule) { 'primary' }
+
+      let(:options) { {targets: ['/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=02']} }
+
+      it { expect(targets).to include '/table/y=2013/m=01/d=01' }
+      it { expect(targets).to include '/table/y=2013/m=01/d=02' }
+      it { expect(sources).to include '/log/20130101.*.log' }
+      it { expect(sources).to include '/log/20130102.*.log' }
+    end
+
+    context 'with :sources' do
+      let(:rule) { 'derived_daily' }
+
+      let(:options) { {sources: ['/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=02']} }
+
+      it { expect(targets).to include "/daily/2013-01-01" }
+      it { expect(targets).to include "/daily/2013-01-02" }
+      it { expect(sources).to include '/table/y=2013/m=01/d=01' }
+      it { expect(sources).to include '/table/y=2013/m=01/d=02' }
+    end
+  end
+
+  describe '#execute' do
+    let(:options) { {} }
+
+    before do
+      engine.prepare(rule, targets: targets)
+    end
+
+    subject(:execute) do
+      engine.execute(rule, options)
+    end
+
+    context 'primary rule' do
+      let(:rule) { 'primary' }
+      let(:targets) {  [
+        '/table/y=2013/m=01/d=01',
+        '/table/y=2013/m=01/d=02',
+        '/table/y=2013/m=01/d=03' ] }
+
+      context 'when target data exists' do
+        before do
+          engine.filesystem.touch!('/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=03')
+          expect(engine.filesystem).to receive(:touch!).never
+          execute
+        end
+
+        it 'should not call touch!' do; end
+      end
+
+      context 'when partial target data exists' do
+        before do
+          engine.filesystem.touch!('/log/20130101.app1.log', '/log/20130102.app1.log', '/log/20130103.app1.log')
+          engine.filesystem.touch!('/table/y=2013/m=01/d=01/DATA', '/table/y=2013/m=01/d=03/DATA')
+          expect(engine.filesystem).to receive(:touch!).with('/table/y=2013/m=01/d=02/DATA').and_call_original
+          execute
+        end
+
+        it 'should call touch!' do; end
+      end
+
+      context 'when source data does not exist' do
+        before do
+          expect(engine.filesystem).to receive(:touch!).never
+          execute
+        end
+
+        it 'should not call touch!' do; end
+      end
+    end
+
+    shared_examples_for 'derived daily data' do
+      context 'when primary target data exists' do
+        let(:derived_targets) {  ['/table/y=2013/m=01/d=01/DATA', '/table/y=2013/m=01/d=02/DATA', '/table/y=2013/m=01/d=03/DATA'] }
+
+        before do
+          engine.filesystem.touch!('/log/20130101.app1.log', '/log/20130102.app1.log', '/log/20130103.app1.log')
+          expect(engine.filesystem).to receive(:touch!).with(*derived_targets).and_call_original
+          expect(engine.filesystem).to receive(:touch!).with(*targets).and_call_original
+          execute
+        end
+
+        it 'should call touch!' do; end
+      end
+
+      context 'when primary target data exists and :resolve is false' do
+        let(:options) { {resolve: false} }
+
+        before do
+          engine.filesystem.touch!('/log/20130101.app1.log', '/log/20130102.app1.log', '/log/20130103.app1.log')
+          expect(engine.filesystem).not_to receive(:touch!)
+          execute
+        end
+
+        it 'should not call touch!' do; end
+      end
+    end
+
+    context 'derived_daily rule' do
+      let(:rule) { 'derived_daily' }
+      let(:targets) { ['/daily/2013-01-01/DATA', '/daily/2013-01-02/DATA', '/daily/2013-01-03/DATA'] }
+
+      it_behaves_like 'derived daily data' do
+        let(:derived_command) { derived_daily_command }
+      end
+    end
+
+    context 'derived_monthly rule' do
+      let(:rule) { 'derived_monthly' }
+      let(:targets) {  ['/monthly/2013-01/DATA'] }
+
+      it_behaves_like 'derived daily data' do
+        let(:derived_command) { derived_monthly_command }
+      end
+    end
+  end
+
+  context 'recursive engines' do
+    before do
+      engine.add_target_rule('primary', path: '/table/y=%Y/m=%m/d=%d')
+      engine.add_source_rule('primary', path: '/log/%Y%m%d.*.log')
+      engine.add_source_rule('derived', path: '/table/y=%Y/m=%m/d=%d')
+      engine.add_target_rule('derived', path: '/log/%Y%m%d.*.log')
+    end
+
+    it 'should raise exception' do
+      expect { engine.prepare('derived', targets: ['/log/20140228.wtf.log']) }.to raise_error /Max depth .* exceeded for rule 'derived'/
+    end
+  end
+end

data/spec/masamune/data_plan/rule_spec.rb

@@ -0,0 +1,407 @@
+#  The MIT License (MIT)
+#
+#  Copyright (c) 2014-2015, VMware, Inc. All Rights Reserved.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+
+require 'spec_helper'
+
+describe Masamune::DataPlan::Rule do
+  let(:engine) { Masamune::DataPlan::Engine.new }
+  let(:name) { 'primary' }
+  let(:type) { :target }
+  let(:pattern) { 'report/%Y-%m-%d/%H' }
+  let(:options) { {path: pattern} }
+
+  let(:instance) { described_class.new(engine, name, type, options) }
+
+  describe '#pattern' do
+    subject do
+      instance.pattern
+    end
+
+    context 'with string' do
+      let(:pattern) { 'report/%Y-%m-%d/%H' }
+      it { is_expected.to eq('report/%Y-%m-%d/%H') }
+    end
+
+    context 'with lambda' do
+      let(:pattern) { lambda { |_| 'report/%Y-%m-%d/%H' } }
+      it { is_expected.to eq('report/%Y-%m-%d/%H') }
+    end
+  end
+
+  describe '#bind_date' do
+    subject(:elem) { instance.bind_date(input_date) }
+
+    context 'with default' do
+      let(:input_date) { DateTime.civil(2013,04,05,23,13) }
+
+      describe '#path' do
+        subject { elem.path }
+        it { is_expected.to eq('report/2013-04-05/23') }
+      end
+      let(:start_time) { DateTime.civil(2013,04,05,23) }
+      let(:stop_time) { DateTime.civil(2013,04,05,0) }
+    end
+
+    context 'with unix timestamp pattern' do
+      let(:pattern) { 'logs/%H-s.log' }
+      let(:input_date) { DateTime.civil(2013,04,05,23,13) }
+
+      describe '#path' do
+        subject { elem.path }
+        it { is_expected.to eq('logs/1365202800.log') }
+      end
+      let(:start_time) { DateTime.civil(2013,04,05,23) }
+      let(:stop_time) { DateTime.civil(2013,04,05,0) }
+    end
+  end
+
+  describe '#bind_input' do
+    subject(:elem) { instance.bind_input(input) }
+
+    context 'with default' do
+      let(:input) { 'report/2013-04-05/23' }
+      let(:output_date) { DateTime.civil(2013,04,05,23) }
+
+      describe '#path' do
+        subject { elem.path }
+        it { is_expected.to eq(input) }
+      end
+
+      describe '#start_time' do
+        subject { elem.start_time }
+        it { is_expected.to eq(output_date) }
+      end
+
+      describe '#stop_time' do
+        subject { elem.stop_time }
+        it { is_expected.to eq(output_date.to_time + 1.hour) }
+      end
+    end
+
+    context 'with unix timestamp pattern' do
+      let(:pattern) { 'logs/%H-s.log' }
+      let(:input) { 'logs/1365202800.log' }
+      let(:output_date) { DateTime.civil(2013,04,05,23) }
+
+      describe '#path' do
+        subject { elem.path }
+        it { is_expected.to eq(input) }
+      end
+
+      describe '#start_time' do
+        subject { elem.start_time }
+        it { is_expected.to eq(output_date) }
+      end
+
+      describe '#stop_time' do
+        subject { elem.stop_time }
+        it { is_expected.to eq(output_date.to_time + 1.hour) }
+      end
+    end
+
+    context 'with previously bound input' do
+      let(:prev_input) { 'report/2013-04-05/23' }
+      let(:input) { instance.bind_input(prev_input) }
+      it { is_expected.to eq(input) }
+    end
+  end
+
+  describe '#unify' do
+    let(:primary) { described_class.new(engine, name, type, {path: 'report/%Y-%m-%d/%H'}) }
+    let(:induced) { described_class.new(engine, name, type, {path: 'table/y=%Y/m=%m/d=%d/h=%H'}) }
+    let(:elem) { primary.bind_input(input) }
+
+    subject(:new_elem) { instance.unify(elem, induced) }
+
+    context 'when input fully matches basis pattern' do
+      let(:input) { 'report/2013-01-02/00' }
+
+      describe '#path' do
+        subject { new_elem.path }
+        it { is_expected.to eq('table/y=2013/m=01/d=02/h=00') }
+      end
+    end
+
+    context 'when input partially matches basis pattern' do
+      let(:induced) { described_class.new(engine, name, type, {path: 'table/%Y-%m'}) }
+
+      let(:input) { 'report/2013-01-02/00' }
+
+      describe '#path' do
+        subject { new_elem.path }
+        it { is_expected.to eq('table/2013-01') }
+      end
+    end
+  end
+
+  describe '#matches' do
+    subject do
+      instance.matches?(input)
+    end
+
+    context 'when input fully matches' do
+      let(:input) { 'report/2013-01-02/00' }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'when input under matches' do
+      let(:input) { 'report/2013-01-02' }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'when input over matches' do
+      let(:pattern) { 'report/%Y-%m-%d' }
+      let(:input) { 'report/2013-01-02/00' }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'when input does not match' do
+      let(:input) { 'report' }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'with alternative hour' do
+      let(:pattern) { 'requests/y=%Y/m=%-m/d=%-d/h=%-k' }
+      let(:input) { 'requests/y=2013/m=5/d=1/h=1' }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'with alternative hour' do
+      let(:pattern) { 'requests/y=%Y/m=%-m/d=%-d/h=%-k' }
+      let(:input) { 'requests/y=2013/m=4/d=30/h=20' }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'with wildcard pattern' do
+      let(:pattern) { 'request_logs/%Y%m%d*request.log' }
+      let(:input) { 'request_logs/20130524.random.request.log' }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'with unix timestamp pattern' do
+      let(:pattern) { 'request_logs/%H-s.log' }
+      let(:input) { 'request_logs/1374192000.log' }
+      it { is_expected.to eq(true) }
+    end
+  end
+
+  describe '#generate' do
+    context 'with a block' do
+      let(:start_date) { DateTime.civil(2013,04,05,20) }
+      let(:stop_date) { DateTime.civil(2013,04,05,20) }
+      specify { expect { |b| instance.generate(start_date, stop_date, &b) }.to yield_control }
+    end
+
+    context 'without a block' do
+      let(:start_date) { DateTime.civil(2013,04,05,20) }
+      let(:stop_date) { DateTime.civil(2013,04,05,22) }
+
+      subject(:elems) do
+        instance.generate(start_date, stop_date)
+      end
+
+      it { expect(elems.map(&:path)).to eq(['report/2013-04-05/20', 'report/2013-04-05/21', 'report/2013-04-05/22']) }
+    end
+  end
+
+  describe '#time_step' do
+    subject { instance.time_step }
+
+    context '24 hour' do
+      let(:pattern) { '%Y-%m-%d/%k' }
+      it { is_expected.to eq(:hours) }
+    end
+    context '24 hour (condensed)' do
+      let(:pattern) { '%Y-%m-%d/%-k' }
+      it { is_expected.to eq(:hours) }
+    end
+    context '12 hour' do
+      let(:pattern) { '%Y-%m-%d/%H' }
+      it { is_expected.to eq(:hours) }
+    end
+    context '12 hour (condensed)' do
+      let(:pattern) { '%Y-%m-%d/%-H' }
+      it { is_expected.to eq(:hours) }
+    end
+    context 'daily' do
+      let(:pattern) { '%Y-%m-%d' }
+      it { is_expected.to eq(:days) }
+    end
+    context 'monthly' do
+      let(:pattern) { '%Y-%m' }
+      it { is_expected.to eq(:months) }
+    end
+    context 'yearly' do
+      let(:pattern) { '%Y' }
+      it { is_expected.to eq(:years) }
+    end
+    context 'hourly unix' do
+      let(:pattern) { '%H-s' }
+      it { is_expected.to eq(:hours) }
+    end
+    context 'daily unix' do
+      let(:pattern) { '%d-s' }
+      it { is_expected.to eq(:days) }
+    end
+    context 'monthly unix' do
+      let(:pattern) { '%m-s' }
+      it { is_expected.to eq(:months) }
+    end
+    context 'yearly unix' do
+      let(:pattern) { '%Y-s' }
+      it { is_expected.to eq(:years) }
+    end
+  end
+
+  describe '#time_round' do
+    let(:input_time) { DateTime.civil(2013,9,13,23,13) }
+    subject { instance.time_round(input_time) }
+
+    before do
+      allow(instance).to receive(:time_step) { time_step }
+    end
+
+    context 'hourly' do
+      let(:time_step) { :hours }
+      it { is_expected.to eq(DateTime.civil(2013,9,13,23)) }
+    end
+    context 'daily' do
+      let(:time_step) { :days }
+      it { is_expected.to eq(DateTime.civil(2013,9,13)) }
+    end
+    context 'monthly' do
+      let(:time_step) { :months }
+      it { is_expected.to eq(DateTime.civil(2013,9)) }
+    end
+    context 'yearly' do
+      let(:time_step) { :years }
+      it { is_expected.to eq(DateTime.civil(2013)) }
+    end
+  end
+
+  describe '#round' do
+    subject(:new_instance) { instance.round(grain) }
+
+    context 'with totally partitioned pattern' do
+      let(:pattern) { 'table/y=%Y/m=%m/d=%d/h=%H' }
+      context 'with :hour' do
+        let(:grain) { :hour }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/y=%Y/m=%m/d=%d/h=%H') }
+        end
+      end
+
+      context 'with :day' do
+        let(:grain) { :day }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/y=%Y/m=%m/d=%d') }
+        end
+      end
+
+      context 'with :month' do
+        let(:grain) { :month }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/y=%Y/m=%m') }
+        end
+      end
+
+      context 'with :year' do
+        let(:grain) { :year }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/y=%Y') }
+        end
+      end
+    end
+
+    context 'with partially partitioned pattern' do
+      let(:pattern) { 'table/%Y-%m-%d/%H' }
+
+      context 'with :hour' do
+        let(:grain) { :hour }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/%Y-%m-%d/%H') }
+        end
+      end
+
+      context 'with :day' do
+        let(:grain) { :day }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/%Y-%m-%d') }
+        end
+      end
+
+      context 'with :month' do
+        let(:grain) { :month }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/%Y-%m-%d') }
+        end
+      end
+
+      context 'with :year' do
+        let(:grain) { :year }
+
+        describe '#pattern' do
+          subject { new_instance.pattern }
+          it { is_expected.to eq('table/%Y-%m-%d') }
+        end
+      end
+    end
+
+    context 'when cannot round due to granularity' do
+      shared_context 'cannot round' do
+        it { expect { subject }.to raise_error RuntimeError, /cannot round to :#{grain} for #{pattern}/ }
+      end
+
+      context 'with :hour' do
+        let(:grain) { :hour }
+        let(:pattern) { 'table/y=%Y/m=%m/d=%d' }
+        include_context 'cannot round'
+      end
+
+      context 'with :day' do
+        let(:grain) { :day }
+        let(:pattern) { 'table/y=%Y/m=%m' }
+        include_context 'cannot round'
+      end
+
+      context 'with :month' do
+        let(:grain) { :month }
+        let(:pattern) { 'table/y=%Y' }
+        include_context 'cannot round'
+      end
+    end
+  end
+end