typingpool 0.8.11 → 0.8.13

data/lib/typingpool/utility/test.rb

@@ -0,0 +1,175 @@
+module Typingpool
+  module Utility
+    module Test
+      require 'vcr'
+      require 'uri'
+      
+      def fixtures_dir
+        File.join(Utility.lib_dir, 'test', 'fixtures')
+      end
+
+      def audio_dir
+        File.join(fixtures_dir, 'audio')
+      end
+
+      def vcr_dir
+        File.join(fixtures_dir, 'vcr')
+      end
+
+      def delete_vcr_fixture(fixture_name)
+        fixture_path = File.join(vcr_dir, [fixture_name, '.yml'].join)
+        File.delete(fixture_path) if File.exist? fixture_path
+      end
+      
+      def cleared_vcr_fixture_path_for(fixture_name)
+        if Typingpool::Test.record
+          delete_vcr_fixture(fixture_name)
+        end
+        if (Typingpool::Test.record || not(Typingpool::Test.live))
+          File.join(vcr_dir, fixture_name)
+        end
+      end
+
+      def with_vcr(fixture_name, config, opts={})
+        if fixture = cleared_vcr_fixture_path_for(fixture_name)
+          read_only = not(Typingpool::Test.record)
+          vcr_load(fixture, config, read_only, opts)
+        end
+        begin
+          yield
+        ensure
+          vcr_stop
+        end
+      end
+
+            #Loads an HTTP mock fixture for playback (default) or
+      #recording. Used in automated tests. Uses the great VCR gem.
+      #
+      #Automatically filters your Config#amazon#key and
+      #Config#amazon#secret from the recorded fixture, and
+      #automatically determines the "cassette" name and "cassette
+      #library" dir from the supplied path.
+      # ==== Params
+      # [fixture_path] Path to where you want the HTTP fixture
+      #                recorded, including filename.
+      # [config]       A Config instance, used to extract the
+      #                Config#amazon#secret and Config#amazon#key that
+      #                will be filtered from the fixture.
+      # [read_only]    Default is true. Set to false to enable recording.
+      # [vcr_params]   Default is nil. A hash of params to pass to
+      #                VCR.insert_cassette (same set of params that
+      #                can be passed to VCR.use_cassette), like
+      #                :preserve_exact_body_bytes or
+      #                :match_requests_on => [:url, :matcher]. If nil,
+      #                no extra params will be passed.
+      # ==== Returns
+      # Result of calling VCR.insert_cassette.
+      def vcr_load(fixture_path, config, read_only=true, vcr_params=nil)
+        VCR.configure do |c|
+          c.cassette_library_dir = File.dirname(fixture_path)
+          c.hook_into :webmock 
+          c.filter_sensitive_data('<AWS_KEY>'){ config.amazon.key }
+          c.filter_sensitive_data('<AWS_SECRET>'){ config.amazon.secret }
+          c.before_record do |interaction|
+            if interaction.request.body.size > 10000
+              interaction.request.body = '<BIG_UPLOAD>'
+            end
+          end #c.before_record do...
+        end
+        WebMock.allow_net_connect! 
+        opts = {:record => (read_only ? :none : :once)}
+        opts.merge!(vcr_params) if vcr_params
+        VCR.turn_on!
+        VCR.insert_cassette(File.basename(fixture_path, '.*'), 
+                            opts
+                           )
+
+      end
+      
+      #Stops playing/recording from the last call to vcr_load. Returns the
+      #result of VCR.eject_cassette.
+      def vcr_stop
+        VCR.eject_cassette
+        VCR.turn_off!
+      end
+
+      #great for s3 because we don't have to worry about changing
+      #bucket names, only matches as far as s3.amazonaws.com
+      def vcr_core_host_matcher
+        lambda do |request1, request2|
+          core_host = lambda{|host| host.split(/\./).reverse.slice(0, 3).reverse.join('.')}
+          core_host.call(URI(request1.uri).host) == core_host.call(URI(request2.uri).host)
+        end #lambda do...
+      end
+
+      def config
+        if File.exist?(File.expand_path(Config.default_file))
+          Config.file
+        else
+          Config.from_bundled_template
+        end
+      end
+
+      def amazon_credentials?(config=self.config)
+        config.amazon && config.amazon.key && config.amazon.secret
+      end
+
+      def s3_credentials?(config)
+        amazon_credentials?(config) && config.amazon.bucket
+      end
+
+      def sftp_credentials?(config)
+        config.sftp && config.sftp.user && config.sftp.host && config.sftp.url
+      end
+
+      def add_goodbye_message(msg)
+        at_exit do
+          STDERR.puts msg
+        end
+      end
+
+      def dummy_config(number=1)
+        Typingpool::Config.file(File.join(fixtures_dir, "config-#{number}"))
+      end
+
+      
+      def project_default
+        Hash[
+             :config_filename => '.config',
+             :subtitle => "Typingpool's test interview transcription",
+             :title => "Typingpool's Test & Interview",
+             :chunks => '0:22',
+             :unusual => ['Hack Day', 'Sunnyvale', 'Chad D'],
+             :voice => ['Ryan', 'Havi, hacker'],
+            ]
+      end
+
+      def works_eventually?(max_seconds=10, min_tries=2)
+        start = Time.now.to_i
+        tries = 0
+        wait = 0
+        until ((tries >= min_tries) && ((Time.now.to_i + wait - start) >= max_seconds)) do
+          sleep wait
+          return true if yield
+          wait = wait > 0 ? wait * 2 : 1
+          tries += 1
+        end
+        false
+      end
+
+      def working_url_eventually?(url, max_seconds=10, min_tries=2, max_redirects=6)
+        works_eventually?(max_seconds, min_tries) do
+          Utility.working_url?(url, max_redirects)
+        end
+      end
+
+      def broken_url_eventually?(url, max_seconds=10, min_tries=2, max_redirects=6)
+        works_eventually?(max_seconds, min_tries) do
+          not(Utility.working_url?(url, max_redirects))
+        end
+      end
+
+      
+    end #Test
+  end #Utility
+end #Typingpool

data/lib/typingpool/utility/test/script.rb

@@ -0,0 +1,342 @@
+module Typingpool
+  module Utility
+    module Test
+      module Script
+        require 'yaml'
+        require 'fileutils'
+        require 'open3'
+        require 'tmpdir'
+        require 'typingpool/utility/test'
+        
+        include Typingpool::Utility::Test
+
+        
+        @@readymade_project_path = nil
+
+        def with_temp_readymade_project
+          Dir.mktmpdir('typingpool_') do |transcripts_dir|
+            FileUtils.cp_r(File.join(readymade_project_path, '.'), transcripts_dir)
+            config = reconfigure_for_transcripts_dir(
+                                                     Config.file(config_path(transcripts_dir)),
+                                                     transcripts_dir)
+            write_config(transcripts_dir, config)
+            reconfigure_project(Project.new(project_default[:title], config))
+            yield(transcripts_dir)
+          end
+        end
+
+        def with_temp_transcripts_dir
+          Dir.mktmpdir('typingpool_') do |transcripts_dir|
+            write_testing_config_for_transcripts_dir(transcripts_dir, self.config)
+            yield(transcripts_dir)
+          end
+        end
+        
+        def reconfigure_for_s3(config)
+          unless s3_credentials?(config)
+            raise Error::Test, "No S3 credentials available"
+          end
+          config.to_hash.delete('sftp')
+          config
+        end
+
+        def reconfigure_for_transcripts_dir(config, transcripts_dir)
+          config.transcripts = transcripts_dir
+          config.cache = File.join(transcripts_dir, '.cache')
+          config
+        end
+        
+        def reconfigure_for_testing(config)
+          config['assign']['reward'] = '0.02'
+          config.assign.to_hash.delete('qualify')
+          config
+        end
+        
+        def write_config(dir, config, filename=project_default[:config_filename])
+          path = File.join(dir, filename)
+          File.write(path, YAML.dump(config.to_hash))
+          path
+        end
+
+        def write_testing_config_for_transcripts_dir(transcripts_dir, config=self.config)
+          write_config(
+                       transcripts_dir,
+                       reconfigure_for_transcripts_dir(reconfigure_for_testing(config), transcripts_dir),
+                       project_default[:config_filename])
+        end
+
+        
+        def readymade_project_path
+          unless @@readymade_project_path
+            transcripts_dir = @@readymade_project_path = Dir.mktmpdir('typingpool_')
+            do_later{ FileUtils.remove_entry_secure(transcripts_dir) }
+            write_testing_config_for_transcripts_dir(transcripts_dir, reconfigure_for_s3(self.config))
+            tp_make(transcripts_dir, config_path(transcripts_dir), 'mp3', true)
+          end
+          @@readymade_project_path
+        end
+
+        def config_path(dir)
+          File.join(dir, project_default[:config_filename])   
+        end
+
+        #Intended to be overriden by some classes that mixin this
+        #module
+        def do_later
+          at_exit{ yield }
+        end
+
+        def reconfigure_project(project)
+          #rewrite URLs in assignment.csv according to config at config_path
+          File.delete(project.local.file('data', 'id.txt'))
+          project.local.create_id
+          reconfigure_project_csv(project)
+          project
+        end
+
+        def reconfigure_project_csv(project)
+          assignments = project.local.file('data', 'assignment.csv').as(:csv)
+          urls = project.create_remote_names(assignments.map{|assignment| Project.local_basename_from_url(assignment['audio_url']) }).map{|file| project.remote.file_to_url(file) }
+          assignments.each! do |assignment|
+            assignment['audio_url'] = urls.shift
+            assignment['project_id'] = project.local.id
+          end
+          assignments
+        end        
+
+        def path_to_script(script_name)
+          File.join(Utility.app_dir, 'bin', script_name)
+        end
+
+        
+        def call_script(script_name, *args)
+          out, err, status = Open3.capture3(path_to_script(script_name), *args)
+          if status.success?
+            return [out.to_s.chomp, err.to_s.chomp]
+          else
+            if err
+              raise Error::Shell, err.chomp
+            else
+              raise Error::Shell
+            end
+          end
+        end
+        
+        def tp_make(in_dir, config=config_path(in_dir), audio_subdir='mp3', devtest_mode_skipping_upload=false, *args)
+          commands = [
+                      '--config', config, 
+                      '--chunks', project_default[:chunks],
+                      *[:title, :subtitle].map{|param| ["--#{param}", project_default[param]] }.flatten,
+                      *[:voice, :unusual].map{|param| project_default[param].map{|value| ["--#{param}", value] } }.flatten,
+                      *audio_files(audio_subdir).map{|path| ['--file', path]}.flatten, 
+                      *args
+                     ]
+          commands.push('--testnoupload', '--testkeepmergefile') if devtest_mode_skipping_upload
+          call_script('tp-make', *commands)
+        end
+
+        def tp_make_with_vcr(dir, fixture_name, config_path=config_path(dir))
+          tp_make(dir, config_path, 'mp3', false, *vcr_args(fixture_name))
+        end
+
+        def vcr_args(fixture_name)
+          args = []
+          if fixture = cleared_vcr_fixture_path_for(fixture_name)
+            args.push('--testfixture', fixture)
+            if Typingpool::Test.record
+              args.push('--testfixturerecord') 
+            end
+          end #if fixture = ...
+          args
+        end
+
+        def tp_finish(dir, config_path=config_path(dir), project_title=project_default[:title], *args)
+          tp_finish_inside_sandbox(dir, config_path, project_title, *args)
+          tp_finish_outside_sandbox(dir, config_path, project_title, *args)
+        end
+
+
+        def tp_finish_inside_sandbox(dir, config_path=config_path(dir), project_title=project_default[:title], *args)
+          tp_finish_outside_sandbox(dir, config_path, project_title, '--sandbox', *args)
+        end
+
+        def tp_finish_outside_sandbox(dir, config_path=config_path(dir), project_title=project_default[:title], *args)
+          call_script('tp-finish', project_title, '--config', config_path, *args)
+        end
+
+        def audio_files(subdir='mp3')
+          dir = File.join(audio_dir, subdir)
+          Dir.entries(dir).reject{|entry| entry.match(/^\./) }.map{|entry| File.join(dir, entry)}.select{|path| File.file?(path) }
+        end
+
+        def assign_default
+          Hash[
+               :template => 'interview/phone',
+               :deadline => '5h',
+               :lifetime => '10h',
+               :approval => '10h',
+               :qualify => ['approval_rate >= 90', 'hits_approved > 10'],
+               :keyword => ['test', 'mp3', 'typingpooltest']
+              ]
+        end
+
+        def tp_assign(dir, config_path=config_path(dir), project_title=project_default[:title], *args)
+          call_script(
+                      'tp-assign',
+                      '--sandbox',
+                      project_title,
+                      assign_default[:template],
+                      '--config', config_path,
+                      *[:deadline, :lifetime, :approval].map{|param| ["--#{param}", assign_default[param]] }.flatten,
+                      *[:qualify, :keyword].map{|param| assign_default[param].map{|value| ["--#{param}", value] } }.flatten,
+                      *args)
+          
+        end
+
+        def tp_assign_with_vcr(dir, fixture_name, config_path=config_path(dir), project_title=project_default[:title])
+          project = Project.new(project_default[:title], Typingpool::Config.file(config_path))
+          args = [dir, config_path, project_title, *vcr_args(fixture_name)]
+          unless (Typingpool::Test.live || Typingpool::Test.record)
+            args.push('--testtime', project_time(project).to_i.to_s)
+          end
+          tp_assign(*args)
+        end
+
+        def copy_tp_assign_fixtures(dir, fixture_prefix, config_path=config_path(dir), project_title=project_default[:title])
+          project = Project.new(project_title, Config.file(config_path))
+          if Typingpool::Test.record
+            project_time(project, Time.now)
+            with_fixtures_in_transcripts_dir(dir, "#{fixture_prefix}_", project_title) do |fixture_path, project_path|
+              FileUtils.cp(project_path, fixture_path)
+            end
+          elsif not(Typingpool::Test.live)
+            copy_fixtures_to_project_dir("#{fixture_prefix}_", File.join(dir, project_title))
+            reconfigure_project_csv(project)
+          end
+        end
+
+        def tp_collect_with_fixture(dir, fixture_name, are_recording=false)
+          fixture_handle = File.join(vcr_dir, fixture_name)
+          args = ['tp-collect', '--sandbox', '--testfixture', fixture_handle, '--config', config_path(dir)]
+          if are_recording
+            delete_vcr_fixture(fixture_name)
+            args.push('--testfixturerecord')
+          end
+          call_script(*args)
+        end
+
+        def tp_review_with_fixture(transcripts_dir, fixture_name, choices, are_recording=false, project_name=nil)
+          fixture_handle = File.join(vcr_dir, fixture_name)
+          output = {}
+          args = [
+                  File.join(Utility.app_dir, 'bin', 'tp-review'),
+                  '--sandbox',
+                  '--config', config_path(transcripts_dir),
+                  '--testfixture', fixture_handle
+                 ]
+          args.push(project_name) if project_name
+          if are_recording
+            delete_vcr_fixture(fixture_name)
+            args.push('--testfixturerecord')
+          end
+          
+          Open3.popen3(*args) do |stdin, stdout, stderr, wait_thr|
+            choices.each do |choice|
+              stdin.puts(choice)
+              if choice.strip.match(/^r/i)
+                stdin.puts("No reason - this is a test")
+              end
+            end
+            output[:out] = stdout.gets(nil)
+            output[:err] = stderr.gets(nil)
+            [stdin, stdout, stderr].each{|stream| stream.close }
+            output[:status] = wait_thr.value
+          end
+          output
+        end
+
+        def tp_config_with_input(args, input)
+          output = {}
+          Open3.popen3(path_to_script('tp-config'), *args) do |stdin, stdout, stderr, wait_thr|
+            input.each do |sending|
+              stdin.puts(sending)
+            end
+            output[:out] = stdout.gets(nil)
+            output[:err] = stderr.gets(nil)
+            [stdin, stdout, stderr].each{|stream| stream.close }
+            output[:status] = wait_thr.value
+          end #Open3.popen3...
+          output
+        end
+        
+        def project_time(project, time=nil)
+          file = project.local.file('data', 'time.txt')
+          if time
+            file.write(time.to_i)
+          else
+            time = Time.at(file.read.to_i)
+          end
+          time
+        end
+        
+        def simulate_failed_audio_upload_in(dir, config_path=config_path(dir))
+          project = Typingpool::Project.new(project_default[:title], Config.file(config_path))
+          csv = project.local.file('data', 'assignment.csv').as(:csv)
+          csv.each!{|a| a['audio_uploaded'] = 'maybe'}
+        end
+
+        def make_fixture_transcripts_dir(name)
+          dir = File.join(fixtures_dir, name)
+          if File.exist? dir
+            raise Error::Test, "Fixture transcript dir already exists for #{name} at #{dir}"
+          end
+          Dir.mkdir(dir)
+          dir
+        end
+
+        def with_fixtures_in_project_dir(fixture_prefix, project_path)
+          fixtures = Dir.entries(fixtures_dir).select{|entry| entry.include?(fixture_prefix) && entry.index(fixture_prefix) == 0 }.select{|entry| File.file?(File.join(fixtures_dir, entry)) }
+          fixtures.map!{|fixture| fixture[fixture_prefix.size .. -1] }
+          fixtures.each do |fixture|
+            project_fixture_path = File.join(project_path, 'data', fixture)
+            source_fixture_path = File.join(fixtures_dir, [fixture_prefix, fixture].join )
+            yield(source_fixture_path, project_fixture_path)
+          end
+        end
+
+        def copy_fixtures_to_project_dir(fixture_prefix, project_path)
+          copies = 0
+          with_fixtures_in_project_dir(fixture_prefix, project_path) do |source_fixture_path, project_fixture_path|
+            if File.exist? project_fixture_path
+              FileUtils.mv(project_fixture_path, File.join(File.dirname(project_fixture_path), "orig_#{File.basename(project_fixture_path)}"))
+            end
+            FileUtils.cp(source_fixture_path, project_fixture_path)
+            copies += 1
+          end
+          copies > 0 or raise Error, "No fixtures to copy with prefix #{fixture_prefix}"
+          copies
+        end
+
+        def restore_project_dir_from_fixtures(fixture_prefix, project_path)
+          with_fixtures_in_project_dir(fixture_prefix, project_path) do |source_fixture_path, project_fixture_path|
+            FileUtils.rm(project_fixture_path)
+            path_to_orig = File.join(File.dirname(project_fixture_path), "orig_#{File.basename(project_fixture_path)}")
+            if File.exist?(path_to_orig)
+              FileUtils.mv(path_to_orig, project_fixture_path)
+            end
+          end #with_fixtures_in_transctips_dir
+        end
+
+        def project_transcript_count(project, which_csv)
+          project.local.file('data', which_csv).as(:csv).reject{|assignment| assignment['transcript'].to_s.empty?}.size
+        end
+
+        def split_reviews(output)
+          output.split(/Transcript for\b/)
+        end
+
+        
+      end #Script      
+    end #Test
+  end #Utility
+end #Typingpool