vpsb_client 0.0.2

data/lib/vpsb_client/manager.rb

@@ -0,0 +1,149 @@
+require 'io/console'
+require 'logger'
+
+require "#{VPSB_BASE_PATH}/vpsb_client/metrics/manager"
+require "#{VPSB_BASE_PATH}/vpsb_client/client/upload_metrics"
+
+module VpsbClient
+  class Manager
+    attr_reader :http_client, :logger, :config
+
+    class LastMetricNotFoundError < StandardError; end
+
+    def initialize(config_path, logger=Logger.new(STDOUT))
+      @config_path = config_path
+      @logger = logger
+    end
+
+    def setup
+      VpsbClient.logger = @logger
+      @config = Config.new(@config_path)
+      @curl_wrapper = CurlWrapper.new(@config['auth_token'])
+      @http_client = HttpClient.new(@curl_wrapper, @config['vpsb_protocol'], @config['vpsb_hostname'])
+    end
+
+    def enabled?
+      @config.fetch(:enabled, false)
+    end
+
+    def signed_in?
+      return @signed_in if @signed_in
+      id_request = Api::GetItemIdRequest.new(@http_client, 'hosters', 'linode')
+      curl_response = id_request.run
+
+      begin
+        http_response = Api::Response.new(curl_response)
+      rescue Api::Response::NotAuthenticated => e
+        return @signed_in = false
+      end
+      @signed_in = true
+    end
+
+    def create_trial
+      unless enabled?
+        VpsbClient.logger.debug "not running because vpsb_client is disabled"
+        return
+      end
+
+      builder = Builders::Trial.new(@config, hoster_id, application_id, plan_id)
+      create_trial_request = Api::CreateTrialRequest.new(@http_client, builder.create_params)
+      curl_response = create_trial_request.run
+      http_response = Api::Response.new(curl_response)
+      Api::CreateTrialRequest.trial(http_response)
+    end
+
+    def current_trial
+      builder = Builders::Trial.new(@config)
+      current_trial_request = Api::GetCurrentTrialRequest.new(@http_client, builder.lookup_params)
+      curl_response = current_trial_request.run
+      http_response = Api::Response.new(curl_response)
+      Api::GetCurrentTrialRequest.trial(http_response)
+    end
+
+    def trial_last_metric_started_at(trial_id, length)
+      current_trial_request = Api::GetTrialLastMetricRequest.new(@http_client, { trial_id: trial_id, length: length})
+      curl_response = current_trial_request.run
+      http_response = Api::Response.new(curl_response)
+      Api::GetTrialLastMetricRequest.started_at(http_response)
+    end
+
+    def hoster_id
+      return @hoster_id if @hoster_id
+      id_request = Api::GetItemIdRequest.new(@http_client, 'hosters', @config['hoster_name'])
+      http_response = Api::Response.new(id_request.run)
+      id = Api::GetItemIdRequest.item_id(http_response)
+      raise NameError, "#{@config['hoster_name']} hoster not found" unless id
+      @hoster_id = id
+    end
+
+    def application_id
+      return @application_id if @application_id
+      id_request = Api::GetItemIdRequest.new(@http_client, 'applications', @config['application_name'])
+      http_response = Api::Response.new(id_request.run)
+      id = Api::GetItemIdRequest.item_id(http_response)
+      raise NameError, "#{@config['application_name']} application not found" unless id
+      @application_id = id
+    end
+
+    def plan_id
+      return @plan_id if @plan_id
+      id_request = Api::GetPlanIdRequest.new(@http_client, hoster_id, @config['plan_name'])
+      http_response = Api::Response.new(id_request.run)
+      id = Api::GetPlanIdRequest.item_id(http_response)
+      raise NameError, "#{@config['plan_name']} plan not found" unless id
+      @plan_id = id
+    end
+
+    include Client::UploadMetrics
+
+    def close_trial(trial)
+      unless enabled?
+        logger.debug "[vpsb] not running because vpsb_client is disabled"
+        return
+      end
+
+      prepare_logfiles
+      
+      metric_ids = []
+      interval_length = 604800
+      last_started_at = trial_last_metric_started_at(trial['id'], interval_length)
+      if last_started_at
+        start_time = last_started_at + interval_length
+      else
+        logger.debug "[vpsb] close_trial - no last metric found"
+        start_time = Time.now - interval_length
+      end
+      logger.debug "[vpsb] close_trial - length=#{interval_length} start_time=#{start_time} force=false"
+      interval_config = Metrics::IntervalConfig.new(start_time, interval_length, force: true)
+      metrics_manager = metrics_manager(trial['id'], interval_config)
+      metrics_manager.run
+      metric_ids += metrics_manager.created_metric_ids
+      logger.debug "[vpsb] Created metric ids: #{metric_ids.inspect}"
+
+      close_request = Api::CloseTrialRequest.new(@http_client, trial['id'])
+      http_response = Api::Response.new(close_request.run)
+      logger.debug "[vpsb] close request response code = #{http_response.code}"
+      http_response
+    end
+
+    private
+
+    def prepare_logfiles
+      sar_manager = Datafiles::SarManager.new(@config['sar_path'], @config['formatted_sar_path'])
+      sar_manager.run
+
+      logfile_decompressor = Datafiles::LogfileDecompressor.new(@config['timing_path'], @config['timing_path'], :filename_prefix => 'timings')
+      logfile_decompressor.run
+    end
+
+
+    def metrics_manager(trial_id, interval_config)
+      min_start_time = interval_config.min_start_time
+      builder         = Metrics::IntervalBuilder.new(@config['formatted_sar_path'], @config['timing_path'], min_start_time, interval_config.length)
+      uploader        = Metrics::Uploader.new(@http_client, trial_id)
+
+      Metrics::Manager.new(builder, uploader, interval_config)
+    end
+
+  end
+end

data/lib/vpsb_client/metrics/interval_builder.rb

@@ -0,0 +1,85 @@
+require "#{File.expand_path('../..', __FILE__)}/datafiles/formatted_sar_log_parser"
+require "#{File.expand_path('../..', __FILE__)}/datafiles/timing_log_parser"
+
+module VpsbClient
+  module Metrics
+    class IntervalBuilder
+      class FileNotFound < StandardError; end
+
+      VALID_METRIC_KEYS = [ :trial_id, :started_at, :duration_seconds, :num_requests, :resptime_total_ms, :resptime_db_ms, :resptime_view_ms, :cpu_idle, :cpu_steal, :iowait, :p50_total_ms, :p75_total_ms, :p95_total_ms, :p99_total_ms, :p75_iowait_pct, :p95_iowait_pct, :p99_iowait_pct,:p75_cpusteal_pct, :p95_cpusteal_pct, :p99_cpusteal_pct, :p75_cpuidle_pct, :p95_cpuidle_pct, :p99_cpuidle_pct ]
+
+      def initialize(sar_path, timing_path, pole_time, interval_length)
+        @sar_path = sar_path
+        @timing_path = timing_path
+        @pole_time = pole_time
+        @interval_length = interval_length
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        sar_filenames = Dir.glob("#{@sar_path}/formatted_sa*")
+        timing_filenames = Dir.glob("#{@timing_path}/timings.log*")
+
+        sar_filenames.reject!    { |f| f =~ /\.gz$/ }
+        timing_filenames.reject! { |f| f =~ /\.gz$/ }
+
+        raise FileNotFound, "No file matching #{@sar_path}/formatted_sa*" unless sar_filenames.any?
+        raise FileNotFound, "No file matching #{@timing_path}/timings.log*" unless timing_filenames.any?
+
+        builder_options = { offset_by_start_time: @pole_time }
+
+        sar_files = LogfileInterval::LogfileSet.new(sar_filenames, Datafiles::FormattedSarLogParser, :desc)
+        timing_files = LogfileInterval::LogfileSet.new(timing_filenames, Datafiles::TimingLogParser, :desc)
+
+        begin
+          sar_builder = LogfileInterval::IntervalBuilder.new(sar_files, Datafiles::FormattedSarLogParser, @interval_length, builder_options)
+          timing_builder = LogfileInterval::IntervalBuilder.new(timing_files, Datafiles::TimingLogParser, @interval_length, builder_options)
+
+          sar_enum = sar_builder.each_interval
+          timing_enum = timing_builder.each_interval
+          while(timing_interval = timing_enum.next) do
+            while(sar_interval = sar_enum.next) do
+              break if sar_interval.start_time == timing_interval.start_time
+              raise "sar_interval older than timing_interval: #{sar_interval.start_time} > #{timing_interval.start_time}" if sar_interval.start_time > timing_interval.start_time
+            end
+
+            yield convert_to_metric(timing_interval, sar_interval)
+          end
+        rescue StopIteration
+        end
+      end
+
+      private
+
+      def convert_to_metric(timing_interval, sar_interval)
+        interval = timing_interval.to_hash.merge(sar_interval)
+        interval[:duration_seconds] = timing_interval.length
+        interval[:started_at] = timing_interval.start_time
+
+        pxx_total_ms = timing_interval[:pxx_total_ms]
+        interval[:p50_total_ms] = pxx_total_ms[50]
+        interval[:p75_total_ms] = pxx_total_ms[75]
+        interval[:p95_total_ms] = pxx_total_ms[95]
+        interval[:p99_total_ms] = pxx_total_ms[99]
+
+        pxx_iowait = sar_interval[:pxx_iowait]
+        interval[:p75_iowait_pct] = pxx_iowait[75]
+        interval[:p95_iowait_pct] = pxx_iowait[95]
+        interval[:p99_iowait_pct] = pxx_iowait[99]
+
+        pxx_cpusteal = sar_interval[:pxx_cpusteal]
+        interval[:p75_cpusteal_pct] = pxx_cpusteal[75]
+        interval[:p95_cpusteal_pct] = pxx_cpusteal[95]
+        interval[:p99_cpusteal_pct] = pxx_cpusteal[99]
+
+        pxx_cpuidle = sar_interval[:pxx_cpuidle]
+        interval[:p75_cpuidle_pct] = 100.0 - pxx_cpuidle[75]
+        interval[:p95_cpuidle_pct] = 100.0 - pxx_cpuidle[95]
+        interval[:p99_cpuidle_pct] = 100.0 - pxx_cpuidle[99]
+
+        interval.select! { |k| VALID_METRIC_KEYS.include?(k) }
+      end
+    end
+  end
+end

data/lib/vpsb_client/metrics/interval_config.rb

@@ -0,0 +1,45 @@
+module VpsbClient
+  module Metrics
+    class IntervalConfig
+      def initialize(start_time, interval_length, options={})
+        @start_time = start_time
+        @interval_length = interval_length
+        @force = options.fetch(:force, false)
+      end
+
+      def aligned?
+        if @force
+          false
+        elsif @interval_length < 86400
+          true
+        else
+          false
+        end
+      end
+
+      def min_start_time
+        if @force
+          @start_time
+        elsif aligned?
+          lower_boundary_time(@start_time)
+        else
+          @start_time
+        end
+      end
+
+      def min_end_time
+        min_start_time + @interval_length
+      end
+
+      def length
+        @interval_length
+      end
+
+      private
+
+      def lower_boundary_time(t)
+        Time.at((t.to_i / @interval_length.to_i) * @interval_length.to_i)
+      end
+    end
+  end
+end

data/lib/vpsb_client/metrics/manager.rb

@@ -0,0 +1,34 @@
+require "#{VPSB_BASE_PATH}/vpsb_client/metrics/interval_builder"
+require "#{VPSB_BASE_PATH}/vpsb_client/metrics/interval_config"
+require "#{VPSB_BASE_PATH}/vpsb_client/metrics/uploader"
+
+module VpsbClient
+  module Metrics
+    class Manager
+      attr_reader :created_metric_ids
+
+      def initialize(builder, uploader, interval_config)
+        @interval_config = interval_config
+        @builder = builder
+        @uploader = uploader
+        @created_metric_ids = []
+      end
+
+      def run
+        if @interval_config.min_end_time > Time.now
+          VpsbClient.logger.info "Skipping #{@interval_config.length} because too early (min_end_time=#{@interval_config.min_end_time})"
+          return
+        end
+
+        @builder.each do |metric|
+          VpsbClient.logger.debug "metric[:started_at]=#{metric[:started_at]} @interval_config.min_start_time=#{@interval_config.min_start_time}"
+          if metric[:started_at] < @interval_config.min_start_time - 1
+            VpsbClient.logger.debug "[vpsb] stop builder loop as #{metric[:started_at]} < #{@interval_config.min_start_time}"
+            break
+          end
+          @created_metric_ids << @uploader.upload(metric)
+        end
+      end
+    end
+  end
+end

data/lib/vpsb_client/metrics/uploader.rb

@@ -0,0 +1,16 @@
+module VpsbClient
+  module Metrics
+    class Uploader
+      def initialize(http_client, trial_id)
+        @http_client = http_client
+        @trial_id = trial_id
+      end
+
+      def upload(metric)
+        upload_request = Api::PostMetricRequest.new(@http_client, @trial_id, metric)
+        http_response = Api::Response.new(upload_request.run)
+        Api::PostMetricRequest.metric_id(http_response)
+      end
+    end
+  end
+end

data/lib/vpsb_client/version.rb

@@ -0,0 +1,3 @@
+module VpsbClient
+  VERSION = "0.0.2"
+end

data/lib/vpsb_client.rb

@@ -0,0 +1,33 @@
+VPSB_BASE_PATH = File.expand_path('..',  __FILE__)
+
+require "#{VPSB_BASE_PATH}/vpsb_client/version"
+require "#{VPSB_BASE_PATH}/vpsb_client/config"
+require "#{VPSB_BASE_PATH}/vpsb_client/http_client"
+require "#{VPSB_BASE_PATH}/vpsb_client/curl_wrapper"
+require "#{VPSB_BASE_PATH}/vpsb_client/manager"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/request"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/response"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/get_current_trial_request"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/get_trial_last_metric_request"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/get_item_id_request"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/create_trial_request"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/post_metric_request"
+require "#{VPSB_BASE_PATH}/vpsb_client/api/close_trial_request"
+require "#{VPSB_BASE_PATH}/vpsb_client/builders/system_info_parser"
+require "#{VPSB_BASE_PATH}/vpsb_client/builders/trial"
+require "#{VPSB_BASE_PATH}/vpsb_client/datafiles/sar_manager"
+require "#{VPSB_BASE_PATH}/vpsb_client/datafiles/logfile_decompressor"
+
+module VpsbClient
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def self.logger
+    if defined?(@@logger)
+      @@logger
+    else
+      @@logger = Logger.new('/dev/null')
+    end
+  end
+end

data/spec/lib/client/upload_metrics_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module VpsbClient
+  module Client
+    describe UploadMetrics do
+      before :each do
+        config = { }
+        @manager = Manager.new('fake_path', Logger.new(STDOUT))
+        allow(@manager).to receive(:prepare_logfiles)
+        allow(@manager).to receive(:enabled?).and_return(true)
+        allow(@manager).to receive(:config).and_return(config)
+      end
+
+      it 'upload metrics for all lengths' do
+        trial = double('trial')
+        expect(@manager).to receive(:upload_for_interval_length).with(trial, 600).and_return([])
+        expect(@manager).to receive(:upload_for_interval_length).with(trial, 3600).and_return([])
+        expect(@manager).to receive(:upload_for_interval_length).with(trial, 86400).and_return([])
+        @manager.upload_metrics(trial)
+      end
+    end
+  end
+end

data/spec/lib/config_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+#require File.join(File.dirname(__FILE__), '..', 'support/lib/timing_log')
+
+module VpsbClient
+  data_dir = File.join(File.dirname(__FILE__), '..', 'support/logfiles')
+
+  describe Config do
+    before :each do
+      support_dir = File.join(File.dirname(__FILE__), '..', 'support/')
+      @config = Config.new("#{support_dir}/vpsb.yml")
+    end
+
+    it 'parses the config file' do
+      expect(@config.fetch('vpsb_hostname')).to eq('localhost:3000')
+    end
+
+    it 'raises an exception for non existent keys' do
+      expect{@config.fetch('foobar')}.to raise_error
+    end
+
+    it 'understands []' do
+      expect{@config.fetch('vpsb_hostname')}.to_not raise_error
+    end
+
+  end
+end

data/spec/lib/logfile_decompressor_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require "#{File.expand_path('../../..',  __FILE__)}/lib/vpsb_client/datafiles/logfile_decompressor"
+
+module VpsbClient
+
+  module Datafiles
+    data_dir = File.join(File.dirname(__FILE__), '..', 'support/timingfiles')
+
+    describe LogfileDecompressor do
+      before :all do
+        @orig_dir = data_dir
+        @target_dir = data_dir
+      end
+
+      context 'without rotation id limit' do
+        before :each do
+          @manager = LogfileDecompressor.new(@orig_dir, @target_dir, :filename_prefix => 'timings')
+        end
+
+        after :each do
+          File.unlink("#{@target_dir}/timings.log.2")
+          File.unlink("#{@target_dir}/timings.log.3")
+        end
+
+        it 'unzips files with .gz extension' do
+          @manager.run
+          expect(File.exist?("#{@target_dir}/timings.log.2")).to be true
+          expect(File.exist?("#{@target_dir}/timings.log.3")).to be true
+        end
+
+        it 'only unzips files with specified prefix' do
+          @manager.run
+          expect(File.exist?("#{@target_dir}/other.log.2")).to be false
+        end
+      end
+
+      context 'with rotation id limit' do
+        before :each do
+          @manager = LogfileDecompressor.new(@orig_dir, @target_dir, :filename_prefix => 'timings',
+                                                                     :max_rotation_id => 2)
+        end
+
+        after :each do
+          File.unlink("#{@target_dir}/timings.log.2")
+        end
+
+        it 'unzips only files below limit' do
+          @manager.run
+          expect(File.exist?("#{@target_dir}/timings.log.2")).to be true
+          expect(File.exist?("#{@target_dir}/timings.log.3")).to be false
+        end
+      end
+
+      context 'without filename prefix' do
+        before :each do
+          @manager = LogfileDecompressor.new(@orig_dir, @target_dir)
+        end
+
+        after :each do
+          File.unlink("#{@target_dir}/timings.log.2")
+          File.unlink("#{@target_dir}/timings.log.3")
+          File.unlink("#{@target_dir}/other.log.2")
+        end
+
+        it 'unzips all files' do
+          @manager.run
+          expect(File.exist?("#{@target_dir}/timings.log.2")).to be true
+          expect(File.exist?("#{@target_dir}/timings.log.3")).to be true
+          expect(File.exist?("#{@target_dir}/other.log.2")).to   be true
+        end
+      end
+    end
+  end
+end

data/spec/lib/metrics/interval_builder_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module VpsbClient
+  module Metrics
+    support_dir = File.join(File.dirname(__FILE__), '../..', 'support/')
+
+    OLDEST_TIME_IN_LOGFILES = Time.new(2014,9,20,0,0,0)
+    NEWEST_TIME_IN_LOGFILES = Time.new(2014,9,21,13,56,0)
+
+    describe IntervalBuilder do
+      before :each do
+        @sar_dir = "#{support_dir}/sarfiles/formatted"
+        @timing_dir = "#{support_dir}/timingfiles"
+        @length = 3600
+        allow(Time).to receive(:now).and_return(NEWEST_TIME_IN_LOGFILES + @length)
+      end
+
+      context 'with aligned pole time' do
+        before :each do
+          aligned_pole_time = OLDEST_TIME_IN_LOGFILES - 12*3600
+          @builder = IntervalBuilder.new(@sar_dir, @timing_dir, aligned_pole_time, @length)
+        end
+
+        it 'should yield once per full hour' do
+          expected_num_intervals = (NEWEST_TIME_IN_LOGFILES - OLDEST_TIME_IN_LOGFILES) / @length
+          expect { |b| @builder.each(&b) }.to yield_control.at_least(expected_num_intervals)
+        end
+
+        describe 'first interval' do
+          it 'is the most recent' do
+            interval_enum = @builder.each
+            expected_start_time = lower_time_boundary(NEWEST_TIME_IN_LOGFILES, @length)
+            expect(interval_enum.next[:started_at]).to eq(expected_start_time)
+            expect(interval_enum.next[:started_at]).to eq(expected_start_time - @length)
+          end
+
+          it 'has the requested length' do
+            i = @builder.each.first
+            expect(i[:duration_seconds]).to eq(@length)
+          end
+
+          it 'has the right averaged timing' do
+            i = @builder.each.first
+            expect(i[:started_at]).to eq(lower_time_boundary(NEWEST_TIME_IN_LOGFILES, @length))
+            expect(i[:resptime_total_ms]).to eq(29.5)
+          end
+
+          it 'as the right p95 cpu idle' do
+            i = @builder.each.first
+            expect(i[:p99_cpuidle_pct]).to eq(88.0)
+          end
+        end
+
+        describe 'last interval' do
+          it 'starts at the oldest data point' do
+            last_interval = nil
+            @builder.each do |i|
+              last_interval = i
+            end
+            expect(last_interval[:started_at]).to eq(OLDEST_TIME_IN_LOGFILES)
+            expect(last_interval[:duration_seconds]).to eq(@length)
+          end
+        end
+      end
+
+      context 'with unaligned pole time' do
+        before :each do
+          @offset = 60
+          unaligned_pole_time = OLDEST_TIME_IN_LOGFILES - 12*3600 + @offset
+          @builder = IntervalBuilder.new(@sar_dir, @timing_dir, unaligned_pole_time, @length)
+        end
+
+        describe 'first interval' do
+          it 'start with on offset start_time' do
+            i = @builder.each.first
+            expected_start_time = lower_time_boundary(NEWEST_TIME_IN_LOGFILES, @length) + @offset
+            expect(i[:started_at]).to eq(expected_start_time)
+          end
+        end
+      end
+
+      def lower_time_boundary(t, len)
+        Time.at((t.to_i / len) * len)
+      end
+    end
+  end
+end
+

data/spec/lib/metrics/interval_config_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+module VpsbClient
+  module Metrics
+    describe IntervalConfig do
+      describe :length do
+        it 'returns the provided length' do
+          ic = IntervalConfig.new(nil, 3600)
+          expect(ic.length).to eq(3600)
+        end
+      end
+
+      describe :min_end_time do
+        it 'is min_start_time + length' do
+          t = Time.new(2014, 11, 15, 20, 0, 0)
+          ic = IntervalConfig.new(t, 3600)
+          expect(ic.min_end_time).to eq(ic.min_start_time + 3600)
+        end
+      end
+
+      context 'with force' do
+        before :each do
+          @forced_start_time = Time.new(2014, 11, 15, 20, 0, 0)
+        end
+
+        context 'with short interval length' do
+          before :each do
+            @length = 60
+            @ic = IntervalConfig.new(@forced_start_time, @length, force: true)
+          end
+
+          it 'aligned? is false' do
+            expect(@ic.aligned?).to eq(false)
+          end
+
+          it 'min_start_time is forced_start_time' do
+            expect(@ic.min_start_time).to eq(@forced_start_time)
+          end
+        end
+
+        context 'with long interval length' do
+          before :each do
+            @length = 604800
+            @ic = IntervalConfig.new(@forced_start_time, @length, force: true)
+          end
+
+          it 'aligned? is false' do
+            expect(@ic.aligned?).to eq(false)
+          end
+
+          it 'min_start_time is forced_start_time' do
+            expect(@ic.min_start_time).to eq(@forced_start_time)
+          end
+        end
+      end
+
+      context 'without force' do
+        before :each do
+          @forced_start_time = nil
+          @fallback_start_time = Time.new(2014, 11, 15, 20, 0, 0)
+        end
+
+        context 'with short interval length' do
+          before :each do
+            @length = 60
+            @ic = IntervalConfig.new(@fallback_start_time, @length)
+          end
+
+          it 'aligned? is true' do
+            expect(@ic.aligned?).to eq(true)
+          end
+
+          it 'min_start_time is lower aligned boundary of fallback_start_time' do
+            expect(@ic.min_start_time).to eq(lower_time_boundary(@fallback_start_time, @length))
+          end
+        end
+
+        context 'with long interval length' do
+          before :each do
+            @length = 604800
+            @ic = IntervalConfig.new(@fallback_start_time, @length)
+          end
+
+          it 'aligned? is false' do
+            expect(@ic.aligned?).to eq(false)
+          end
+
+          it 'min_start_time is fallback_start_time' do
+            expect(@ic.min_start_time).to eq(@fallback_start_time)
+          end
+        end
+      end
+
+      def lower_time_boundary(t, len)
+        Time.at((t.to_i / len) * len)
+      end
+    end
+  end
+end