typingpool 0.7.0

data/test/test_unit_amazon.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(File.dirname($0)), 'lib')
+
+require 'typingpool'
+require 'typingpool/test'
+require 'uri'
+require 'cgi'
+
+class TestAmazon < Typingpool::Test
+
+  def test_amazon_base
+    setup_result = Typingpool::Amazon.setup(:sandbox => true, :config => dummy_config)
+    assert_match(setup_result, /amazonaws/)
+    assert(Typingpool::Amazon.cache)
+    assert_instance_of(PStore, Typingpool::Amazon.cache)
+    assert_equal(dummy_config.cache, Typingpool::Amazon.cache.path)
+    assert(full_rturk_hit = Typingpool::Amazon.rturk_hit_full('test'))
+    assert_instance_of(RTurk::Hit, full_rturk_hit)
+  end
+
+  def test_amazon_question
+    assert(question = dummy_question)
+    assert_instance_of(Typingpool::Amazon::Question, question)
+    assert_equal(question_url, question.url)
+    assert_equal(question_html, question.html)
+    assert_match(question.title, /Transcribe MP3 of/i)
+    assert_match(question.description, /telephone conversation/i)
+    assert_match(question.annotation, /\S/)
+    assert(decoded_annotation = URI.decode_www_form(CGI.unescapeHTML(question.annotation)))
+    decoded_annotation = Hash[*decoded_annotation.flatten]
+    assert_match(decoded_annotation[Typingpool::Amazon::HIT.url_at], /^http/i)
+    assert_match(decoded_annotation[Typingpool::Amazon::HIT.id_at], /\S/)
+  end
+
+  def test_amazon_hit_create
+    with_dummy_hit_or_skip('test_amazon_hit_create') do |hit, config|
+      assert_equal(hit.full.external_question_url, dummy_question.url)
+      assert_equal(config.assign.deadline, hit.full.assignments_duration.to_i)
+      assert(rturk_hit = hit.at_amazon)
+      assert_equal(dummy_question.annotation.to_s, CGI.escapeHTML(rturk_hit.annotation.to_s))
+      assert_equal(dummy_question.title.strip, rturk_hit.title.strip)
+      assert_equal(dummy_question.description.strip, rturk_hit.description.strip)
+      assert_equal(config.assign.reward.to_f, rturk_hit.reward.to_f)
+      assert_equal(config.assign.keywords.first.to_s, rturk_hit.keywords.first.to_s)
+    end #with_dummy_hit
+  end
+
+  #fails to test all_reviewable or all_approved - those require a VCR fixture (TODO)
+  def test_amazon_hit_retrievers
+    with_dummy_hit_or_skip('test_amazon_hit_retrievers') do |hit, config|
+      assert(result = Typingpool::Amazon::HIT.with_ids([hit.id]))
+      assert_equal(1, result.count)
+      assert_equal(hit.id, result.first.id)
+      assert(result = Typingpool::Amazon::HIT.all_for_project(hit.project_id))
+      assert_equal(1, result.count)
+      assert_equal(hit.id, result.first.id)
+      assert(results = Typingpool::Amazon::HIT.all)
+      assert(results.count > 0)
+      assert(results = Typingpool::Amazon::HIT.all{|incoming_hit| incoming_hit.id == hit.id })
+      assert_equal(1, results.count)
+      assert_equal(hit.id, result.first.id)
+    end #with_dummy_hit
+  end
+
+  #fails to properly test approved?, rejected?, submitted?, assignment - those require a VCR ficture (TODO)
+  def test_amazon_hit_base
+    with_dummy_hit_or_skip('test_amazon_hit_base') do |hit, config|
+      assert_instance_of(Typingpool::Amazon::HIT, hit)
+      assert_match(hit.id, /\S/)
+      assert_match(hit.url, /^http/i)
+      assert_match(hit.project_id, /\S/)
+      assert_match(hit.project_title_from_url, /\S/)
+      assert(not(hit.approved?))
+      assert(not(hit.rejected?))
+      assert(not(hit.submitted?))
+      assert(hit.ours?)
+      assert_instance_of(Typingpool::Transcript::Chunk, hit.transcript)
+      assert_kind_of(RTurk::Hit, hit.at_amazon)
+      assert_instance_of(Typingpool::Amazon::HIT::Full, hit.full)
+      assert_instance_of(Typingpool::Amazon::HIT::Assignment::Empty, hit.assignment)
+    end #with_dummy_hit_or_skip
+  end
+
+  #fails to test external_question* methods
+  def test_amazon_hit_full
+    with_dummy_hit_or_skip('test_amazon_hit_full') do |hit, config|
+      assert(full = hit.full)
+      assert_instance_of(Typingpool::Amazon::HIT::Full, full)
+      [:id, :type_id].each{|attr| assert_match(full.send(attr), /\S/) }
+      assert(not(full.expired?))
+      assert(not(full.expired_and_overdue?))
+      assert_equal('Assignable', full.status)
+      assert_match(full.external_question_url, /^http/i)
+      [:assignments_completed, :assignments_pending].each{|attr| assert_match(full.send(attr).to_s, /^\d+$/) }
+      assert_kind_of(Time, full.expires_at)
+      assert_instance_of(Hash, full.annotation)
+      assert_match(full.annotation[Typingpool::Amazon::HIT.url_at], /^http/i)
+      assert_match(full.annotation[Typingpool::Amazon::HIT.id_at], /\S/)
+    end #with_dummy_hit_or_skip
+  end
+
+  def test_amazon_hit_full_fromsearchhits
+    with_dummy_hit_or_skip('test_amazon_hit_full_fromsearchhits') do |hit, config|
+      assert(full = hit.full)
+      assert_instance_of(Typingpool::Amazon::HIT::Full, full)
+      assert(hit2 = Typingpool::Amazon::HIT.all{|incoming_hit| incoming_hit.id == hit.id }.first)
+      assert_equal(hit.id, hit2.id)
+      assert(full2 = hit2.full)
+      assert_instance_of(Typingpool::Amazon::HIT::Full::FromSearchHITs, full2)
+      assert_equal(full.annotation.to_s, full2.annotation.to_s)
+      [:assignments_completed, :assignments_pending, :id, :type_id, :status, :expires_at, :assignments_duration, :external_question_url].each{|attr| assert_equal(full.send(attr).to_s, full2.send(attr).to_s) }
+    end #with_dummy_hit_or_skip
+  end
+
+  #Lacks test for HIT::Assignment - needs VCR fixture (TODO)
+
+  def question_html
+    File.read(File.join(fixtures_dir, 'amazon-question-html.html'))
+  end
+
+  def question_url
+    File.read(File.join(fixtures_dir, 'amazon-question-url.txt')).strip
+  end
+
+  def dummy_question
+    Typingpool::Amazon::Question.new(question_url, question_html)
+  end
+
+  def dummy_hit(config)
+    Typingpool::Amazon::HIT.create(dummy_question, config.assign)
+  end
+
+  def with_dummy_hit_or_skip(skipping_what)
+    config = self.config
+    skip_if_no_amazon_credentials(skipping_what, config)
+    config.assign.reward = '0.01'
+    cache = Tempfile.new('typingpool_cache')
+    begin
+      config.cache = cache.path
+      Typingpool::Amazon.setup(:sandbox => true, :config => config)
+      hit = dummy_hit(config)
+      begin
+        yield(hit, config)
+      ensure
+        hit.remove_from_amazon
+      end #begin
+    ensure
+      cache.close
+      cache.unlink
+    end #begin
+  end
+end #TestAmazon

data/test/test_unit_config.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(File.dirname($0)), 'lib')
+
+require 'typingpool'
+require 'typingpool/test'
+
+class TestConfig < Typingpool::Test
+
+  def test_config_regular_file
+    assert(config = Typingpool::Config.file(File.join(fixtures_dir, 'config-1')))
+    assert_equal('~/Documents/Transcripts/', config['transcripts'])
+    assert_match(config.transcripts, /Transcripts$/)
+    refute_match(config.transcripts, /~/)
+    %w(key secret).each do |param| 
+      regex = /test101010/
+      assert_match(config.amazon.send(param), regex) 
+      assert_match(config.amazon[param], regex)
+      assert_match(config.amazon.to_hash[param], regex)
+    end
+    assert_equal(0.75, config.assign.reward.to_f)
+    assert_equal(3*60*60, config.assign.deadline.to_i)
+    assert_equal('3h', config.assign['deadline'])
+    assert_equal(60*60*24*2, config.assign.lifetime.to_i)
+    assert_equal('2d', config.assign['lifetime'])
+    assert_equal(3, config.assign.keywords.count)
+    assert_kind_of(Typingpool::Config::Root::Assign::Qualification, config.assign.qualify.first)
+    assert_equal(:approval_rate, config.assign.qualify.first.to_arg[0])
+    assert_equal(:gte, config.assign.qualify.first.to_arg[1].keys.first)
+    assert_equal('95', config.assign.qualify.first.to_arg[1].values.first.to_s)
+  end
+
+  def test_config_sftp
+    assert(config = Typingpool::Config.file(File.join(fixtures_dir, 'config-2')))
+    assert_equal('ryan', config.sftp.user)
+    assert_equal('public_html/transfer/', config.sftp['path'])
+    assert_equal('public_html/transfer', config.sftp.path)
+    assert_equal('http://example.com/mturk/', config.sftp['url'])
+    assert_equal('http://example.com/mturk', config.sftp.url)
+  end
+
+  def test_config_screwy_file
+    assert(config = Typingpool::Config.file(File.join(fixtures_dir, 'config-2')))
+
+    exception = assert_raises(Typingpool::Error::Argument) do 
+      config.assign.qualify
+    end
+    assert_match(exception.message, /Unknown qualification type/i)
+
+    config.assign['qualify'] = [config.assign['qualify'].pop]
+    exception = assert_raises(Typingpool::Error::Argument) do 
+      config.assign.qualify
+    end
+    assert_match(exception.message, /Unknown comparator/i)
+
+    assert_equal('3z', config.assign['deadline'])
+    exception = assert_raises(Typingpool::Error::Argument::Format) do
+      config.assign.deadline
+    end
+    assert_match(exception.message, /can't convert/i)
+
+    config.assign['reward'] = 'foo'
+    exception = assert_raises(Typingpool::Error::Argument::Format) do
+      config.assign.reward
+    end
+    assert_match(exception.message, /\bformat should\b/i)
+  end
+
+  def test_config_regular_input
+    assert(config = Typingpool::Config.file(File.join(fixtures_dir, 'config-1')))
+    new_reward = '0.80'
+    refute_equal(config.assign.reward, new_reward)
+    assert(config.assign.reward = new_reward)
+    assert_equal(new_reward, config.assign.reward)
+    
+    new_time = '11d'
+    refute_equal(new_time, config.assign.approval)
+    assert(config.assign.approval = new_time)
+    assert_equal(950400, config.assign.approval)
+  end
+
+  def test_config_screwy_input
+    exception = assert_raises(Typingpool::Error::Argument::Format) do
+      config.assign.reward = 'foo'
+    end
+    assert_match(exception.message, /\bformat should\b/i)
+
+    exception = assert_raises(Typingpool::Error::Argument::Format) do
+      config.assign.approval = '11f'
+    end
+    assert_match(exception.message, /can't convert/i)
+
+  end
+end #TestConfig

data/test/test_unit_filer.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(File.dirname($0)), 'lib')
+
+require 'typingpool'
+require 'typingpool/test'
+require 'fileutils'
+
+class TestFiler < Typingpool::Test
+
+  def test_filer_base
+    path = File.join(fixtures_dir, 'config-1')
+    assert(filer = Typingpool::Filer.new(path))
+    assert_equal(path, "#{filer}")
+    assert(text = filer.read)
+    assert_match(text, /^amazon:\n/)
+    assert_match(text, /transcripts: ~\/Documents\/Transcripts\//)
+    assert_match(text, /- mp3\s*$/)
+    assert_equal(fixtures_dir, filer.dir.path)
+    in_temp_dir do |dir|
+      path = File.join(dir, 'filer-temp')
+      assert(filer = Typingpool::Filer.new(path))
+      assert_instance_of(Typingpool::Filer::CSV, filer_csv = filer.as(:csv))
+      assert_equal(filer.path, filer_csv.path)
+      assert_nil(filer.read)
+      data = "foo\nbar\nbaz."
+      assert(filer.write(data))
+      assert_equal(data, filer.read)
+      assert(path = filer.mv!(File.join(dir, 'filer-temp-2')))
+      assert(File.exists? filer.path)
+      assert_equal('filer-temp-2', File.basename(filer.path))
+    end #in_temp_dir
+  end
+
+  def test_filer_csv
+    path = File.join(fixtures_dir, 'tp_review_sandbox-assignment.csv')
+    assert(filer = Typingpool::Filer::CSV.new(path))
+    assert_equal(path, "#{filer}")
+    assert(data = filer.read)
+    assert_instance_of(Array, data)
+    assert_instance_of(Hash, data.first)
+    assert_respond_to(filer, :each)
+    assert_respond_to(filer, :map)
+    assert_respond_to(filer, :select)
+    assert(data.first['audio_url'])
+    assert_match(data.first['audio_url'], /^https?:\/\/\w/)
+    assert(filer.select{|r| r['audio_url'] }.count > 0)
+    in_temp_dir do |dir|
+      path = File.join(dir, 'filer-temp')
+      assert(filer2 = Typingpool::Filer::CSV.new(path))
+      assert_equal([], filer2.read)
+      assert(filer2.write(data))
+      assert_equal(Typingpool::Filer.new(filer.path).read, Typingpool::Filer.new(filer2.path).read)
+      assert_equal(filer.count, filer2.count)
+      filer2.each! do |row|
+        row['audio_url'] = row['audio_url'].reverse
+      end
+      rewritten = Typingpool::Filer.new(filer2.path).read
+      assert(Typingpool::Filer.new(filer.path).read != rewritten)
+      keys = filer2.first.keys
+      filer2.write_arrays(filer2.map{|row| keys.map{|key| row[key] } }, keys)
+      assert_equal(rewritten, Typingpool::Filer.new(filer2.path).read)
+    end #in_temp_dir
+  end
+
+  #This might be more comprehensive if it looped and ran once with
+  #Encoding set to 'US-ASCII' - but we'd have to be carefult to reset
+  #Encoding back to orig value. For now I just run ruby -E 'US-ASCII'
+  #test_unit_filer.rb now and again.
+  def test_filer_csv_utf8
+    path = File.join(fixtures_dir, 'tp_review_sandbox-assignment.csv')
+    assert(filer = Typingpool::Filer::CSV.new(path))
+    assert(data = filer.read)
+    assert_instance_of(Array, data)
+    assert_instance_of(Hash, data.first)
+    in_temp_dir do |dir|
+      path = File.join(dir, 'filer-temp')
+      assert(filer2 = Typingpool::Filer::CSV.new(path))
+      assert_equal([], filer2.read)
+      assert(filer2.write(data))
+      assert_equal(Typingpool::Filer.new(filer.path).read, Typingpool::Filer.new(filer2.path).read)
+      refute_empty(assignments = filer2.read)
+      assert(assignment = assignments.pop)
+      assert(assignment['transcript'] = File.read(File.join(fixtures_dir, 'utf8_transcript.txt'), :encoding => 'UTF-8'))
+      assignments.push(assignment)
+      assert(filer2.write(assignments)) 
+      refute_empty(filer2.read) #will throw ArgumentError: invalid byte sequence in US-ASCII in degenerate case
+    end #in_temp_dir
+  end
+
+  def test_filer_audio
+    mp3 = Typingpool::Filer::Audio.new(files_from(File.join(audio_dir, 'mp3')).first)
+    wma = Typingpool::Filer::Audio.new(files_from(File.join(audio_dir, 'wma')).first)
+    assert(mp3.mp3?)
+    assert(not(wma.mp3?))
+    in_temp_dir do |dir|
+      [mp3, wma].each do |file|
+        FileUtils.cp(file, dir)
+      end
+      mp3 = Typingpool::Filer::Audio.new(File.join(dir, File.basename(mp3)))
+      wma = Typingpool::Filer::Audio.new(File.join(dir, File.basename(wma)))
+      dest = Typingpool::Filer::Audio.new(File.join(dir, 'filer-temp.mp3'))
+      assert(converted = wma.to_mp3(dest))
+      assert_equal(dest.path, converted.path)
+      assert(wma.bitrate >= 30)
+      assert(wma.bitrate <= 40)
+      assert(converted.bitrate)
+      assert(converted.mp3?)
+      assert(chunks = mp3.split('0.25', 'filer-temp', Typingpool::Filer::Dir.new(dir)))
+      assert(not(chunks.to_a.empty?))
+      assert_equal(3, chunks.count)
+      chunks.each{|chunk| assert(File.exists? chunk) }
+      assert(chunks.first.offset)
+      assert_match(chunks.first.offset, /0\.00\b/)
+      assert_match(chunks.to_a[1].offset, /0\.25\b/)
+    end #in_temp_dir
+  end
+
+  def files_from(dir)
+    Dir.entries(dir).map{|entry| File.join(dir, entry) }.select{|path| File.file? path }.reject{|path| path.match(/^\./) }
+  end
+
+  def test_filer_files_base
+    file_selector = /tp[_-]collect/
+    dir = fixtures_dir
+    files = files_from(dir).select{|path| path.match(file_selector) }
+    dir = File.join(fixtures_dir, 'vcr')
+    files.push(*files_from(dir).select{|path| path.match(file_selector) })
+    assert(files.count > 0)
+    assert(filer = Typingpool::Filer::Files.new(files.map{|path| Typingpool::Filer.new(path) }))
+    assert_equal(filer.files.count, files.count)
+    assert_respond_to(filer, :each)
+    assert_respond_to(filer, :select)
+    assert_respond_to(filer, :map)
+    assert_instance_of(Typingpool::Filer::Files::Audio, filer.as(:audio))
+  end
+
+  def test_filer_files_audio
+    mp3s = files_from(File.join(audio_dir, 'mp3')).map{|path| Typingpool::Filer::Audio.new(path) }
+    wmas = files_from(File.join(audio_dir, 'wma')).map{|path| Typingpool::Filer::Audio.new(path) }
+    assert(mp3s.count > 0)
+    assert(wmas.count > 0)
+    assert(filer_mp3 = Typingpool::Filer::Files::Audio.new(mp3s))
+    assert(filer_wma = Typingpool::Filer::Files::Audio.new(wmas))
+    assert_equal(mp3s.count, filer_mp3.files.count)
+    assert_equal(wmas.count, filer_wma.files.count)
+    in_temp_dir do |dir|
+      dest_filer = Typingpool::Filer::Dir.new(dir)
+      assert(filer_conversion = filer_wma.to_mp3(dest_filer))
+      assert_equal(filer_wma.files.count, filer_conversion.files.count)
+      assert_equal(filer_wma.files.count, filer_conversion.select{|file| File.exists? file }.count)
+      assert_equal(filer_wma.files.count, filer_conversion.select{|file|  file.mp3? }.count)
+      assert_equal(filer_conversion.files.count, dest_filer.files.count)
+      temp_path = File.join(dir, 'temp.mp3')
+      assert(filer_merged = filer_mp3.merge(Typingpool::Filer.new(temp_path)))
+      assert(File.size(filer_merged) > File.size(filer_mp3.first))
+      assert(filer_merged.mp3?)
+      assert(filer_merged.path != filer_mp3.first.path)
+      assert(filer_merged.path != filer_mp3.to_a[1].path)
+    end #in_temp_dir
+  end
+
+  def test_filer_dir
+    assert(dir = Typingpool::Filer::Dir.new(fixtures_dir))
+    assert_equal(fixtures_dir, dir.path)
+    dir2_path = File.join(fixtures_dir, 'doesntexist')
+    assert(not(File.exists? dir2_path))
+    assert(dir2 = Typingpool::Filer::Dir.new(dir2_path))
+    in_temp_dir do |dir|
+      dir3_path = File.join(dir, 'filer-dir-temp')
+      assert(not(File.exists? dir3_path))
+      assert(dir3 = Typingpool::Filer::Dir.create(dir3_path))
+      assert(File.exists? dir3_path)
+      assert_instance_of(Typingpool::Filer::Dir, dir3)
+      assert_nil(dir2 = Typingpool::Filer::Dir.named(File.basename(dir2_path), File.dirname(dir2_path)))
+      assert(dir3 = Typingpool::Filer::Dir.named(File.basename(dir3_path), File.dirname(dir3_path)))
+      assert_instance_of(Typingpool::Filer::Dir, dir3)
+      assert_equal(dir3_path, dir3.to_s)
+      assert_equal(dir3_path, dir3.to_str)
+      assert(filer = dir3.file('doesntexist'))
+    end #in_temp_dir
+    assert(filer = dir.file('vcr', 'tp-collect-1.yml'))
+    assert(File.exists? filer.path)
+    assert_instance_of(Typingpool::Filer, filer)
+    assert(csv = dir.file('tp_collect_sandbox-assignment.csv').as(:csv))
+    assert(File.exists? csv.path)
+    assert_instance_of(Typingpool::Filer::CSV, csv)
+    dir4 = Typingpool::Filer::Dir.new(audio_dir)
+    assert(audio = dir4.file('mp3', 'interview.1.mp3').as(:audio))
+    assert(File.exists? audio.path)
+    assert_instance_of(Typingpool::Filer::Audio, audio)
+    assert(filers = dir.files)
+    assert(not(filers.empty?))
+    assert_kind_of(Typingpool::Filer, filers.first)
+    assert(File.exists? filers.first.path)
+    dir_files = Dir.entries(dir.path).map{|entry| File.join(dir.path, entry)}.select{|path| File.file?(path) }.reject{|path| File.basename(path).match(/^\./) }
+    assert_equal(dir_files.count, filers.count)
+    assert(dir5 = dir.subdir('vcr'))
+    assert(File.exists? dir5.path)
+    assert_instance_of(Typingpool::Filer::Dir, dir5)
+  end
+end #TestFiler

data/test/test_unit_project.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(File.dirname($0)), 'lib')
+
+require 'typingpool'
+require 'typingpool/test'
+require 'tmpdir'
+require 'fileutils'
+require 'uri'
+
+class TestProject < Typingpool::Test
+  def test_project_base_new
+    assert(project = Typingpool::Project.new(project_default[:title], dummy_config))
+    assert_instance_of(Typingpool::Project, project)
+    assert_equal(project_default[:title], project.name)
+    assert_equal(dummy_config.to_hash.to_s, project.config.to_hash.to_s)
+    assert_raise(Typingpool::Error::Argument::Format) do 
+      Typingpool::Project.new('one/two', dummy_config)
+    end #assert_raise...
+  end
+
+  def test_project_base_bitrate
+    assert(project = Typingpool::Project.new(project_default[:title], dummy_config))
+    bitrate = rand(999) + 1
+    assert(project.bitrate = bitrate)
+    assert_equal(bitrate, project.bitrate)
+    bitrate = rand 
+    assert_raises(Typingpool::Error::Argument::Format) do
+      project.bitrate = bitrate
+    end
+  end
+
+  def test_project_base_interval
+    assert(project = Typingpool::Project.new(project_default[:title], dummy_config))
+    assert(project.interval = 120)
+    assert_equal(120, project.interval)
+    assert_equal(1, set_and_return_interval(project, '01'))
+    assert_equal(1, set_and_return_interval(project, 1))
+    assert_equal("0:01", project.send(:interval_as_time_string))
+    assert_equal(2, set_and_return_interval(project, 2))
+    assert_equal("0:02", project.send(:interval_as_time_string))
+    assert_raises(Typingpool::Error::Argument::Format) do 
+      set_and_return_interval(project, 2.1)
+    end
+    assert_equal(11, set_and_return_interval(project,11))
+    assert_equal("0:11", project.send(:interval_as_time_string))
+    assert_equal(1, set_and_return_interval(project, '00:01'))
+    assert_equal(60, set_and_return_interval(project, '01:00'))
+    assert_equal("1:00", project.send(:interval_as_time_string))
+    assert_equal(60, set_and_return_interval(project, '1:00'))
+    assert_equal(3552, set_and_return_interval(project, '59:12'))
+    assert_equal("59:12", project.send(:interval_as_time_string))
+    assert_equal(3680, set_and_return_interval(project, '61:20'))
+    assert_equal("1:01:20", project.send(:interval_as_time_string))
+    assert_raises(Typingpool::Error::Argument::Format) do 
+      set_and_return_interval(project, '61:20.1')
+    end
+    assert_equal(7152, set_and_return_interval(project, '01:59:12'))
+    assert_equal("1:59:12", project.send(:interval_as_time_string))
+    assert_equal(7152, set_and_return_interval(project, '1:59:12'))
+    assert_raises(Typingpool::Error::Argument::Format) do 
+      set_and_return_interval(project, '01:59:12.01')
+    end
+    assert_equal(43152, set_and_return_interval(project, '11:59:12'))
+    assert_equal("11:59:12", project.send(:interval_as_time_string))
+  end
+
+  def test_project_base_interval_as_mds
+    assert(project = Typingpool::Project.new(project_default[:title], dummy_config))
+    assert_equal('0.1', set_and_return_interval_as_mds(project, 1))
+    assert_equal('0.2', set_and_return_interval_as_mds(project, 2))
+    assert_equal('0.11', set_and_return_interval_as_mds(project,11))
+    assert_equal('1.0', set_and_return_interval_as_mds(project, '01:00'))
+    assert_equal('59.12', set_and_return_interval_as_mds(project, '59:12'))
+    assert_equal('61.20', set_and_return_interval_as_mds(project, '61:20'))
+    assert_equal('119.12', set_and_return_interval_as_mds(project, '1:59:12'))
+    assert_equal('719.12', set_and_return_interval_as_mds(project, '11:59:12'))
+  end
+
+  def test_project_base_local
+    config = dummy_config
+    config.transcripts = fixtures_dir
+    assert(project = Typingpool::Project.new('project', config))
+    assert_nil(project.local)
+    valid_transcript_dir = File.join(Typingpool::Utility.lib_dir, 'templates')
+    assert_kind_of(Typingpool::Project::Local, project.local(valid_transcript_dir))
+    config.transcripts = valid_transcript_dir
+    assert(project = Typingpool::Project.new('project', config))
+    assert_kind_of(Typingpool::Project::Local, project.local)
+  end
+
+  def test_project_base_remote
+    assert(project = Typingpool::Project.new(project_default[:title], dummy_config(1)))
+    assert_instance_of(Typingpool::Project::Remote::S3, project.remote)
+    assert(project = Typingpool::Project.new(project_default[:title], dummy_config(2)))
+    assert_instance_of(Typingpool::Project::Remote::SFTP, project.remote)
+    config = dummy_config(2)
+    config.to_hash.delete('sftp')
+    assert(project = Typingpool::Project.new(project_default[:title], config))
+    assert_raises(Typingpool::Error) do
+      project.remote
+    end
+  end
+
+  def test_project_base_create_local
+    config = dummy_config
+    in_temp_dir do |dir|
+      config.transcripts = dir
+      assert(project = Typingpool::Project.new(project_default[:title], config))
+      assert_nil(project.local)
+      assert_kind_of(Typingpool::Project::Local, project.create_local)
+      assert_kind_of(Typingpool::Project::Local, project.local)      
+    end #in_temp_dir do
+  end
+
+  def test_project_base_create_assignment_csv
+    config = dummy_config
+    in_temp_dir do |dir|
+      config.transcripts = dir
+      assert(project = Typingpool::Project.new(project_default[:title], config))
+      project.create_local
+      assert(project.interval = '1:00')
+      assert_kind_of(Typingpool::Project::Local, project.local)
+      dummy_remote_files = (1..5).map{|n| "#{project_default[:title]}.#{n}" }
+      relative_path = ['data', 'assignment.csv']
+      voices = project_default[:voice].map do |voice|
+        spec = voice.split(/,\s*/)
+        hash = {:name => spec[0]}
+        hash[:description] = spec[1] if spec[1]
+        hash
+      end
+      assert(result = project.create_assignment_csv(:path => relative_path, :urls => dummy_remote_files, :unusual => project_default[:unusual], :voices => voices, ))
+      assert_includes(result, dir)
+      csv_file = File.join(dir, project_default[:title], *relative_path)
+      assert(File.exists? csv_file)
+      assert(File.file? csv_file)
+      assert(parsed = CSV.read(csv_file))
+      assignment_headers = parsed.shift
+      assert_equal(dummy_remote_files.count, parsed.count)
+      assert(chunk_index = assignment_headers.find_index('chunk'))
+      assert_equal('1:00', parsed.first[chunk_index].to_s)
+      assert(chunk_minutes_index = assignment_headers.find_index('chunk_minutes'))
+      assert_equal(1, parsed.first[chunk_minutes_index].to_i)
+      assert(chunk_seconds_index = assignment_headers.find_index('chunk_seconds'))
+      assert_empty(parsed.first[chunk_seconds_index].to_s)
+      assert(voices_count_index = assignment_headers.find_index('voices_count'))
+      assert_equal(voices.count, parsed.first[voices_count_index].to_i)
+      assert(voice_2_title_index = assignment_headers.find_index('voice2title'))
+      refute_empty(parsed.first[voice_2_title_index].to_s)
+    end #in_temp_dir do
+  end
+
+  def test_local_basename_from_url
+    url = ['http://example.com/dir/', URI.escape('Example Title With Spaces & Ampersand.html')].join
+    assert_match(url, /%20/)
+#assert(basename = Typingpool::Project.local_basename_from_url.u)
+  end
+
+  def set_and_return_interval(project, interval)
+    project.interval = interval
+    project.interval
+  end
+
+  def set_and_return_interval_as_mds(project, interval)
+    project.interval = interval
+    project.interval_as_min_dot_sec
+  end
+end #TestProject

data/test/test_unit_project_local.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(File.dirname($0)), 'lib')
+
+require 'typingpool'
+require 'typingpool/test'
+
+class TestProjectLocal < Typingpool::Test
+  def test_project_local_ours
+    assert(File.exists?(non_project_dir))
+    assert(File.directory?(non_project_dir))
+    refute(Typingpool::Project::Local.ours?(Typingpool::Filer::Dir.new(non_project_dir)))
+    assert(File.exists?(project_template_dir))
+    assert(Typingpool::Project::Local.ours?(Typingpool::Filer::Dir.new(project_template_dir)))
+  end
+
+  def test_project_local_named
+    assert_nil(Typingpool::Project::Local.named(project_default[:title], fixtures_dir))
+    assert_kind_of(Typingpool::Project::Local, local = Typingpool::Project::Local.named('project', project_template_dir_parent))
+  end
+
+  def test_project_local_valid_name
+    assert(Typingpool::Project::Local.valid_name?('hello, world'))
+    refute(Typingpool::Project::Local.valid_name?('hello / world'))
+  end
+
+  def test_project_local_create
+    in_temp_dir do |dir|
+      assert(local = create_project_local(dir))
+      assert(File.exists?(local.path))
+      assert(File.directory?(local.path))
+      assert_kind_of(Typingpool::Project::Local, local)
+      refute_nil(local.id)
+    end
+  end
+
+  def test_project_instance
+    in_temp_dir do |dir|
+      assert(local = create_project_local(dir))
+      refute_nil(local.id)
+      assert_raise(Typingpool::Error) do
+        local.create_id
+      end
+      assert_nil(local.subtitle)
+      [:subtitle].each do |accessor|
+        text = 'hello, world'
+        assert(local.send("#{accessor.to_s}=".to_sym, text))
+        assert_equal(text, local.send(accessor))
+      end #[].each do...
+    end #in_temp_dir do..
+  end
+
+  def create_project_local(dir)
+    Typingpool::Project::Local.create(project_default[:title], dir, project_template_dir)
+  end
+
+  def project_template_dir
+    File.join(project_template_dir_parent, 'project')
+  end
+
+  def project_template_dir_parent
+    File.join(Typingpool::Utility.lib_dir, 'templates')
+  end
+
+  def non_project_dir
+    File.join(fixtures_dir, 'vcr')
+  end
+end #TestProjectLocal