kaede 0.1.0

data/spec/kaede/notifier_spec.rb

@@ -0,0 +1,60 @@
+# coding: utf-8
+require 'spec_helper'
+
+require 'kaede/notifier'
+require 'kaede/program'
+
+describe Kaede::Notifier do
+  let(:notifier) { described_class.new }
+  let(:duration) { 30 }
+  let(:program) { Kaede::Program.new(1234, 5678, Time.now, Time.now + duration, nil, 19, 9, '6', 0, 'sub', 'title', 'comment') }
+
+  describe '#notify_before_record' do
+    it 'tweets' do
+      expect(notifier).to receive(:tweet).with(/title #6 sub/)
+      notifier.notify_before_record(program)
+    end
+  end
+
+  describe '#notify_after_record' do
+    before do
+      Kaede.configure do |config|
+        config.record_dir = @tmpdir.join('record').tap(&:mkpath)
+        tools = @topdir.join('tools')
+        config.statvfs = tools.join('statvfs')
+      end
+
+      notifier.record_path(program).open('w') {}
+    end
+
+    it 'tweets' do
+      expect(notifier).to receive(:tweet).with(/title #6 sub.*0\.00GB/)
+      notifier.notify_after_record(program)
+    end
+  end
+
+  describe '#notify_exception' do
+    class MyException < Exception
+    end
+
+    it 'tweets' do
+      Kaede.configure do |config|
+        config.twitter_target = nil
+      end
+
+      expect(notifier).to receive(:tweet).with(/MyException で失敗した/)
+      notifier.notify_exception(MyException.new, program)
+    end
+
+    context 'when twitter_target is set' do
+      it 'tweets to twitter_target' do
+        Kaede.configure do |config|
+          config.twitter_target = 'eagletmt'
+        end
+
+        expect(notifier).to receive(:tweet).with(/\A@eagletmt .* MyException で失敗した/)
+        notifier.notify_exception(MyException.new, program)
+      end
+    end
+  end
+end

data/spec/kaede/recorder_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+require 'kaede'
+require 'kaede/database'
+require 'kaede/recorder'
+require 'kaede/updater'
+
+describe Kaede::Recorder do
+  let(:notifier) { double('Notifier') }
+  let(:recorder) { described_class.new(notifier) }
+  let(:db) { Kaede::Database.new(':memory:') }
+  let(:job) { db.get_jobs.first }
+  let(:program) { db.get_program(job[:pid]) }
+  let(:duration) { 30 }
+
+  let(:formatted_fname) { '5678_1234 title #6 sub (comment) at MX' }
+  let(:record_dir) { @tmpdir.join('record').tap(&:mkpath) }
+  let(:record_path) { recorder.record_path(program) }
+  let(:cache_dir) { @tmpdir.join('cache').tap(&:mkpath) }
+  let(:cache_path) { recorder.cache_path(program) }
+  let(:cache_ass_path) { recorder.cache_ass_path(program) }
+  let(:cabinet_dir) { @tmpdir.join('cabinet').tap(&:mkpath) }
+  let(:cabinet_path) { recorder.cabinet_path(program) }
+  let(:cabinet_ass_path) { recorder.cabinet_ass_path(program) }
+
+  before do
+    db.add_channel(Kaede::Channel.new(nil, 'MX', 9, 19))
+    channel = db.get_channels.first
+    program = Kaede::Program.new(1234, 5678, Time.now, Time.now + duration, nil, 19, 9, '6', 0, 'sub', 'title', 'comment')
+    db.update_program(program, channel)
+    db.update_job(program.pid, Time.now + 5)
+
+    Kaede.configure do |config|
+      config.redis = double('redis')
+      tools = @topdir.join('tools')
+      config.recpt1 = tools.join('recpt1')
+      config.b25 = tools.join('b25')
+      config.assdumper = tools.join('assdumper')
+      config.statvfs = tools.join('statvfs')
+      config.clean_ts = tools.join('clean-ts')
+      config.record_dir = record_dir
+      config.cache_dir = cache_dir
+      config.cabinet_dir = cabinet_dir
+    end
+  end
+
+  describe '#record' do
+    it 'calls before_record -> do_record -> after_record' do
+      expect(recorder).to receive(:before_record).ordered.with(program)
+      expect(recorder).to receive(:do_record).ordered.with(program)
+      expect(recorder).to receive(:after_record).ordered.with(program)
+
+      expect { recorder.record(db, job[:pid]) }.to output(/Start #{job[:pid]}.*Done #{job[:pid]}/m).to_stdout
+    end
+
+    it 'notifies exception' do
+      e = Class.new(Exception)
+      expect(notifier).to receive(:notify_exception).with(e, program)
+      allow(recorder).to receive(:before_record)
+      allow(recorder).to receive(:do_record).and_raise(e)
+      allow(recorder).to receive(:after_record)
+
+      expect { recorder.record(db, job[:pid]) }.to raise_error(e)
+    end
+  end
+
+  describe '#after_record' do
+    before do
+      record_path.open('w') {}
+      cache_path.open('w') {}
+      cache_ass_path.open('w') { |f| f.puts 'ass' }
+
+      allow(Kaede.config.redis).to receive(:rpush)
+      allow(notifier).to receive(:notify_after_record).with(program)
+    end
+
+    it 'calls Notifier#notify_after_record' do
+      expect(notifier).to receive(:notify_after_record).with(program)
+      recorder.after_record(program)
+    end
+
+    it 'cleans cached TS' do
+      expect(cache_path).to be_exist
+      expect(cabinet_path).to_not be_exist
+
+      recorder.after_record(program)
+
+      expect(cache_path).to_not be_exist
+      expect(cabinet_path).to be_exist
+    end
+
+    it 'moves ass' do
+      expect(cache_ass_path).to be_exist
+      expect(cabinet_ass_path).to_not be_exist
+
+      recorder.after_record(program)
+
+      expect(cache_ass_path).to_not be_exist
+      expect(cabinet_ass_path).to be_exist
+    end
+
+    it 'enqueues to redis' do
+      expect(Kaede.config.redis).to receive(:rpush).with(Kaede.config.redis_queue, formatted_fname)
+
+      recorder.after_record(program)
+    end
+
+    context 'with empty ass' do
+      before do
+        cache_ass_path.open('w') {}
+      end
+
+      it 'removes ass' do
+        expect(cache_ass_path).to be_exist
+        expect(cabinet_ass_path).to_not be_exist
+
+        recorder.after_record(program)
+
+        expect(cache_ass_path).to_not be_exist
+        expect(cabinet_ass_path).to_not be_exist
+      end
+    end
+  end
+
+  describe '#do_record' do
+    it 'creates raw TS in record dir' do
+      expect(record_path).to_not be_exist
+      recorder.do_record(program)
+      expect(record_path).to be_exist
+      expect(record_path.read.chomp).to eq("#{program.channel_for_recorder} #{duration - 10}")
+    end
+
+    it 'creates b25-decoded TS in cache dir' do
+      expect(cache_path).to_not be_exist
+      recorder.do_record(program)
+      expect(cache_path).to be_exist
+      expect(cache_path.read.chomp).to eq(record_path.read.chomp.reverse)
+    end
+
+    it 'creates ass in cache dir' do
+      expect(cache_ass_path).to_not be_exist
+      recorder.do_record(program)
+      expect(cache_ass_path).to be_exist
+      expect(cache_ass_path.read.chomp).to eq(record_path.read.chomp.gsub('1', '2'))
+    end
+  end
+
+  describe '#calculate_duration' do
+    subject { recorder.calculate_duration(program) }
+
+    it 'returns duration' do
+      is_expected.to eq(duration - 10)
+    end
+
+    context 'with NHK (which has no CM)' do
+      before do
+        program.channel_name = 'NHK-G'
+      end
+
+      it 'has additional record time' do
+        is_expected.to eq(duration + Kaede::Updater::JOB_TIME_GAP)
+      end
+    end
+
+    context 'with MX on Sunday 22:00' do
+      before do
+        program.start_time = Time.local(2014, 4, 6, 22, 00)
+        program.end_time = Time.local(2014, 4, 6, 22, 27)
+      end
+
+      it 'has 30min duration even if Syoboi Calendar says 27min' do
+        is_expected.to eq(30*60 - 10)
+      end
+    end
+  end
+end

data/spec/kaede/scheduler_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+require 'tempfile'
+require 'timeout'
+require 'kaede'
+require 'kaede/database'
+require 'kaede/recorder'
+require 'kaede/scheduler'
+
+describe Kaede::Scheduler do
+  let(:db_file) { Tempfile.open('kaede.db') }
+  let(:db) { Kaede::Database.new(db_file.path) }
+
+  describe '.start' do
+    let(:program) { Kaede::Program.new(1234, 5678, Time.now, Time.now + 30, nil, 19, 9, '5.5', 0, 'sub', 'title', '') }
+
+    before do
+      db.add_channel(Kaede::Channel.new(nil, 'MX', 9, 19))
+      channel = db.get_channels.first
+      db.update_program(program, channel)
+      db.update_job(program.pid, Time.now + 5)
+    end
+
+    it 'works' do
+      r, w = IO.pipe
+      allow_any_instance_of(Kaede::Recorder).to receive(:record) { |recorder, db, pid|
+        program = db.get_program(pid)
+        puts "Record #{program.pid}"
+      }
+      pid = fork do
+        r.close
+        $stdout.reopen(w)
+        described_class.setup(db)
+        described_class.start
+      end
+      w.close
+
+      expect(db.get_jobs.size).to eq(1)
+      begin
+        Timeout.timeout(10) do
+          while s = r.gets.chomp
+            if s =~ /\ARecord (\d+)\z/
+              expect($1.to_i).to eq(program.pid)
+              break
+            end
+          end
+        end
+      ensure
+        Process.kill(:QUIT, pid)
+        Process.waitpid(pid)
+      end
+      expect(db.get_jobs.size).to eq(0)
+    end
+  end
+end

data/spec/kaede/syoboi_calendar_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'kaede/syoboi_calendar'
+
+describe Kaede::SyoboiCalendar do
+  let(:client) { described_class.new }
+
+  describe '#cal_chk' do
+    it 'works' do
+      VCR.use_cassette('cal_chk/all') do
+        programs = client.cal_chk
+        programs.each do |program|
+          program.members.each do |attr|
+            next if [:channel_name, :channel_for_recorder].include?(attr)
+            expect(program[attr]).to_not be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/kaede/updater_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'kaede/channel'
+require 'kaede/database'
+require 'kaede/syoboi_calendar'
+require 'kaede/updater'
+
+describe Kaede::Updater do
+  let(:db) { Kaede::Database.new(':memory:') }
+  let(:syobocal) { Kaede::SyoboiCalendar.new }
+  let(:updater) { described_class.new(db, syobocal) }
+
+  describe '#update' do
+    let(:channel) { Kaede::Channel.new(nil, 'MX', 9, 19) }
+    let(:tracking_tid) { 3225 }
+
+    let(:expected_pid) { 279855 }
+    let(:expected_enqueued_at) { Time.local(2014, 3, 6, 21, 59, 45) }
+
+    around do |example|
+      Timecop.travel(Time.local(2014, 3, 5, 18, 0)) do
+        example.run
+      end
+    end
+
+    before do
+      db.add_channel(channel)
+      db.add_tracking_title(tracking_tid)
+
+      allow(updater).to receive(:reload_scheduler)
+      @orig_stderr = $stderr
+      $stderr = open(File::NULL, 'w')
+    end
+
+    after do
+      $stderr = @orig_stderr
+    end
+
+    it 'inserts new jobs' do
+      VCR.use_cassette('cal_chk/days7') do
+        updater.update
+      end
+
+      jobs = db.get_jobs
+      expect(jobs.size).to eq(1)
+      job = jobs[0]
+      expect(job[:pid]).to eq(expected_pid)
+      expect(job[:enqueued_at]).to eq(expected_enqueued_at)
+    end
+
+    it 'updates existing job' do
+      dummy_time = Time.local(2014, 3, 6, 20, 29, 45)
+
+      VCR.use_cassette('cal_chk/days7') do
+        updater.update
+      end
+      db.update_job(expected_pid, dummy_time)
+      job1 = db.get_jobs[0]
+      expect(job1[:enqueued_at]).to eq(dummy_time)
+      VCR.use_cassette('cal_chk/days7') do
+        updater.update
+      end
+      job2 = db.get_jobs[0]
+      expect(job2[:enqueued_at]).to eq(expected_enqueued_at)
+      expect(job2[:pid]).to eq(job1[:pid])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'coveralls'
+require 'simplecov'
+require 'timecop'
+require 'tmpdir'
+require 'vcr'
+require 'webmock/rspec'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter,
+]
+SimpleCov.start do
+  add_filter Bundler.bundle_path.to_s
+  add_filter File.dirname(__FILE__)
+
+  # Kaede::Scheduler is tested in another process.
+  add_filter 'lib/kaede/scheduler.rb'
+end
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/fixtures/vcr'
+  config.hook_into :webmock
+end
+
+RSpec.configure do |config|
+  # config.profile_examples = 10
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  config.before :each do
+    @topdir = Pathname.new(__FILE__).parent
+  end
+
+  config.around :each do |example|
+    Dir.mktmpdir('kaede') do |dir|
+      @tmpdir = Pathname.new(dir)
+      example.run
+    end
+  end
+end

data/spec/tools/assdumper

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec sed -e s/1/2/ "$1"

data/spec/tools/b25

@@ -0,0 +1,6 @@
+#!/bin/sh
+shift
+shift
+shift
+
+exec rev "$1" > "$2"

data/spec/tools/clean-ts

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec cp "$1" "$2"