fontprocessor 27.1.3

data/lib/fontprocessor/version.rb

@@ -0,0 +1,3 @@
+module FontProcessor
+  VERSION = "27.1.3"
+end

data/lib/fontprocessor.rb

@@ -0,0 +1,16 @@
+require 'digest'
+require 'ots-ruby'
+require 'skytype'
+require 'tmpdir'
+
+require 'fontprocessor/config'
+require 'fontprocessor/external_execution'
+require 'fontprocessor/font_file'
+require 'fontprocessor/font_file_naming_strategy'
+require 'fontprocessor/font_format'
+require 'fontprocessor/process_font_job'
+require 'fontprocessor/processed_font_iterator'
+require 'fontprocessor/processor'
+
+module FontProcessor
+end

data/scripts/build_and_test.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -eax
+
+bundle install --deployment
+
+bundle exec rspec
+
+rm -rf `bundle show skytype`/ext/skytype \
+        `bundle show skytype`/ext/obj \
+        `bundle show skytype`/testData \
+        spec \
+        fixtures
+
+

data/scripts/get_production_source_map.rb

@@ -0,0 +1,53 @@
+# This is a script that can be run on a production `typekit` server to create
+# a CSV file mapping font base IDs and processing versions to locations in the
+# production source files bucket. This can be used to download those source
+# files for local development and testing with an in-progress font processing
+# version.
+#
+# The input to this script should be a CSV with family names and slugs. The
+# output is another CSV file with individual font variations in each of those
+# families, along with FVD and source file location in the S3 bucket.
+#
+# TO BE RUN IN A PRODUCTION TYPEKIT CONSOLE
+
+data = File.read("/tmp/source_families.csv")
+data = data.split("\n")[1..-1].join("\n") # Remove first line
+family_data = FasterCSV.parse(data, {
+  :headers => ["Name", "Slug", "Notes"],
+  :return_headers => false,
+  :skip_blanks => true
+})
+
+client = FontBase::Client.new do |c|
+  c.connection = Mongo::Connection.from_uri(Typekit.config.font_base_db_uri)
+  c.db_name = Typekit.config.font_base_db
+  c.s3_bucket = Typekit.config.s3_font_base_source
+end
+
+output_data = FasterCSV.generate do |csv|
+  csv << ["Family Name", "Variation Name", "Slug", "FVD", "Font Base ID", "CFF Filename", "CFF Source ID", "TTF Filename", "TTF Source ID"]
+  family_data.each do |family_row|
+    tff = TypekitFontFamily.get_by_slug(family_row["Slug"])
+    tff.font_variations.each do |fv|
+      if ff = fv.current_font_file
+        font_base_id = ff.font_base_id
+        files = client.get(font_base_id)["files"]
+        cff_filename, cff_source_id = if files.has_key?("cff")
+          [files["cff"]["filename"], files["cff"]["key"]]
+        else
+          [nil, nil]
+        end
+        ttf_filename, ttf_source_id = if files.has_key?("ttf")
+          [files["ttf"]["filename"], files["ttf"]["key"]]
+        else
+          [nil, nil]
+        end
+        csv << [tff.name, fv.name, family_row["Slug"], fv.fvd, font_base_id, cff_filename, cff_source_id, ttf_filename, ttf_source_id]
+      end
+    end
+  end
+end
+
+File.open("/tmp/source_files.csv", "w") do |f|
+  f.write(output_data)
+end

data/spec/fixtures/fixtures.rb

@@ -0,0 +1,35 @@
+require 'tmpdir'
+
+module FontProcessor
+  module Specs
+    class Fixture
+
+      def initialize(kind)
+        @kind = kind
+        FileUtils.mkdir_p(temp_directory)
+        FileUtils.cp(filepath, temp_directory)
+      end
+
+      def destroy
+        FileUtils.rm_rf(temp_directory)
+      end
+
+      def naming_strategy
+        FontProcessor::FontFileNamingStrategy.new(filename, temp_directory)
+      end
+
+      def temp_directory
+        File.join(Dir.tmpdir, @kind.to_s)
+      end
+
+      protected
+        def filename
+          "#{@kind}.otf"
+        end
+
+        def filepath
+          File.join(File.dirname(__FILE__), filename)
+        end
+    end
+  end
+end

data/spec/lib/fontprocessor/config_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe FontProcessor::Config do
+  subject { FontProcessor::Config }
+
+  describe "the environment" do
+    it "defaults to development" do
+      expect(subject.environment).to eq "development"
+    end
+    context "when set to test" do
+      before(:all) do
+        ENV['ENV'] = "test"
+      end
+      after(:all) do
+        ENV.delete('ENV')
+      end
+      it "is test" do
+        expect(subject.environment).to eq "test"
+      end
+    end
+  end
+
+  it "has an s3 source bucket" do
+    expect(subject.s3_source_bucket).to eq "typekit-development-source-fonts"
+  end
+
+  it "has an s3 processed bucket" do
+    expect(subject.s3_processed_bucket).to eq "typekit-development-processed-fonts"
+  end
+
+  it "has a mongo host" do
+    expect(subject.mongo_host).to eq "localhost"
+  end
+
+  it "has a mongo db" do
+    expect(subject.mongo_db).to eq "fontbase_development"
+  end
+end

data/spec/lib/fontprocessor/external_execution_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe FontProcessor::ExternalStdOutCommand do
+  it "should be able to execute a normal binary and get it's output" do
+    result = FontProcessor::ExternalStdOutCommand.run('echo asdf', :expect_output => true)
+    expect(result).to eq "asdf\n"
+  end
+
+  it "should be able to kill a hanging binary" do
+    result = FontProcessor::ExternalStdOutCommand.run('cat', :timeout => 1)
+    expect(result).to be_nil
+  end
+
+  it "should be able to execute a normal binary and get it's stderr with it's stdout" do
+    result = FontProcessor::ExternalStdOutCommand.run('cat asdfjhasdjfkhasdkjfhasjdkhf', :expect_output => true)
+    expect(result).to include("No such file or directory")
+  end
+end
+
+describe FontProcessor::ExternalJSONProgram do
+  it "should be able to execute a program that takes and receives JSON" do
+    result = FontProcessor::ExternalJSONProgram.run('more', {:param1 => 'test'})
+    expect(result.key?('param1')).to be true
+  end
+  it "should be able to kill a hanging binary" do
+    expect { FontProcessor::ExternalJSONProgram.run('sleep 2', :timeout => 1) }.to raise_error(FontProcessor::ExternalProgramError, "sleep 2: Took longer than 1 seconds to respond")
+  end
+  it "should be able to handle a binary that outputs to stderr first" do
+    FontProcessor::ExternalJSONProgram.run('python -c "import sys;sys.stdin.read();sys.stderr.write(\'e\ne\');sys.stdout.write(\'{\\"1\\": [\'+\'1,\'*((65535/2)+1)+\'2]}\n\')"', {})
+    # If this didn't hang then we are good, otherwise we have a problem
+    expect(1).to eq 1
+  end
+end

data/spec/lib/fontprocessor/font_file_naming_strategy_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FontProcessor::FontFileNamingStrategy do
+  before(:all) do
+    @naming_strategy = FontProcessor::FontFileNamingStrategy.new("postscript.otf", "fixtures")
+    @charset_id = "1"
+  end
+
+  it "can name a character set" do
+    expect(@naming_strategy.char_set(@charset_id, FontProcessor::FontFormat.new(:ttf, :otf))).to eq "fixtures/charset-#{@charset_id}-otf.ttf"
+    expect(@naming_strategy.char_set(@charset_id, FontProcessor::FontFormat.new(:cff, :otf))).to eq "fixtures/charset-#{@charset_id}-otf.otf"
+  end
+end

data/spec/lib/fontprocessor/font_file_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'fixtures/fixtures'
+
+describe FontProcessor::FontFile do
+  context "with a PostScript file" do
+    before(:each) do
+      @fixture = FontProcessor::Specs::Fixture.new(:postscript)
+      @file = FontProcessor::FontFile.new(@fixture.naming_strategy.source)
+    end
+
+    after(:each) do
+      @fixture.destroy
+    end
+
+    it "can inspect the name table" do
+      expect(@file.names.keys.count).to eq 1
+      expect(@file.names["en"].keys.sort).to eq ["Unique ID", "Version", "Trademark",
+        "PostScript name", "Subfamily", "Description", "Designer", "Designer URL",
+        "License Description", "License URL", "Vendor URL", "Manufacturer",
+        "Full name", "Family", "Copyright", "Compatible Full", "PostScript CID",
+        "Preferred Family", "Preferred Subfamily", "Reserved",
+        "Sample text", "WWS Family Name", "WWS Subfamily Name"].sort
+      expect(@file.names["en"]["PostScript name"]).to eq "Lobster1.4"
+    end
+
+    it "can inspect it's metrics" do
+      metrics = @file.metrics
+      expect(metrics.keys.sort).to eq ["hhea_linegap", "os2_weight", "upos",
+        "max_descent", "os2_width", "os2_panose", "hhea_descent", "max_ascent",
+        "optical_size", "os2_windescent", "os2_typolinegap", "os2_typoascent",
+        "os2_typodescent", "os2_winascent", "em", "hhea_ascent"].sort
+
+      expect(metrics['em']).to eq 1000
+      expect(metrics['max_ascent']).to eq 1000
+      expect(metrics['max_descent']).to eq -250
+      expect(metrics['upos']).to eq -50
+      expect(metrics['hhea_descent']).to eq -250
+      expect(metrics['hhea_ascent']).to eq 1000
+      expect(metrics['hhea_linegap']).to eq 28
+      expect(metrics['os2_windescent']).to eq 250
+      expect(metrics['os2_winascent']).to eq 1000
+      expect(metrics['os2_typoascent']).to eq 700
+      expect(metrics['os2_typodescent']).to eq -250
+      expect(metrics['os2_typolinegap']).to eq 56
+      expect(metrics['os2_weight']).to eq 400
+      expect(metrics['os2_width']).to eq 5
+      # the test font does not have an optical size, so it should be nil
+      expect(metrics['optical_size']).to be_nil
+    end
+
+    it "can get the optical size from a fon with it" do
+      opt_size_fixture = FontProcessor::Specs::Fixture.new(:op_size)
+      opt_file = FontProcessor::FontFile.new(opt_size_fixture.naming_strategy.source)
+      metrics = opt_file.metrics
+      expect(metrics.keys.sort).to eq ["hhea_linegap", "os2_weight", "upos",
+                              "max_descent", "os2_width", "os2_panose", "hhea_descent", "max_ascent",
+                              "os2_windescent", "os2_typolinegap", "os2_typoascent", "optical_size",
+                              "os2_typodescent", "os2_winascent", "em", "hhea_ascent"].sort
+      expect(metrics['optical_size']).to eq 180
+    end
+
+    it "can identify the Unicode codepoints contained within a font" do
+      characters = [(32..126), (161..174), (176..255), (260..265)]
+      characters = characters.map { |r| r.to_a }.flatten
+      characters.each do |c|
+        expect(@file.unicode.include?(c)).to be true
+      end
+    end
+
+    it "can extract OpenType features" do
+      feature_hash = JSON.parse @file.features
+      expect(feature_hash.has_key?("GPOS")).to be true
+      expect(feature_hash.has_key?("GSUB")).to be true
+      gpos_features = feature_hash["GPOS"]
+      expect(gpos_features).to eq ["kern"]
+      gsub_features = feature_hash["GSUB"]
+      expect(gsub_features).to eq ["aalt", "liga", "salt"]
+    end
+
+
+    it "contains PostScript outlines" do
+      expect(@file.has_postscript_outlines?).to be true
+      expect(@file.has_truetype_outlines?).to be false
+    end
+
+    it "has a helper function to compact arrays of consecutive integers into ranges" do
+      expect(@file.send(:compact_ranges, [1,2,3,7,8,9])).to eq [Range.new(1,3), Range.new(7,9)]
+      expect(@file.send(:compact_ranges, [1,3,7,2,8,9])).to eq [Range.new(1,3), Range.new(7,9)]
+      expect(@file.send(:compact_ranges, [1,3,7,2,8,9,11])).to eq [Range.new(1,3), Range.new(7,9), 11]
+      expect(@file.send(:compact_ranges, [1,2,3,5,7,8,9,11,13])).to eq [Range.new(1,3), 5, Range.new(7,9), 11, 13]
+    end
+  end
+
+  context "with a file containing TrueType outlines" do
+    before(:each) do
+      @fixture = FontProcessor::Specs::Fixture.new(:truetype)
+      naming_strategy = @fixture.naming_strategy
+      @file = FontProcessor::FontFile.new(naming_strategy.source)
+    end
+
+    after(:each) do
+      @fixture.destroy
+    end
+
+    it "contains TrueType outlines" do
+      expect(@file.has_truetype_outlines?).to be true
+      expect(@file.has_postscript_outlines?).to be false
+    end
+  end
+end

data/spec/lib/fontprocessor/process_font_job_spec.rb

@@ -0,0 +1,317 @@
+require 'spec_helper'
+
+describe FontProcessor::ProcessFontJob do
+  before(:each) do
+    @status_key = "status:/a00000000000000000000001/20/1/woffsvgswf"
+    @font_base_id = "a00000000000000000000001"
+    @request_data = '{"version":"0.3","request_type":"web_processing_request","font_base_id":"a00000000000000000000001","fpv":"21","charset":{"charset_id":"1","unicode":"0x0020..0x007e,0x00a0..0xffff","features":"ALL"},"formats":{"process_original":true,"convert":true,"derivatives":["dyna_base","woff","woff2","inst","svg","swf"]}}'
+    @no_convert = '{"version":"0.3","request_type":"web_processing_request","font_base_id":"a00000000000000000000001","fpv":"21","charset":{"charset_id":"1","unicode":"0x0020..0x007e,0x00a0..0xffff","features":"ALL"},"formats":{"process_original":true,"convert":false,"derivatives":["dyna_base","woff","woff2","inst","svg","swf"]}}'
+    @charset_id = "1"
+    @fpv = "21"
+    @directory = "/tmp/#{@font_base_id}-#{@charset_id}"
+  end
+  subject { FontProcessor::ProcessFontJob }
+
+  describe "integration tests" do
+    it "can successfully process a font" do
+      expect(subject).to receive(:fetch_files).ordered
+      expect(subject).to receive(:process_files).ordered
+      expect(subject).to receive(:upload_metadata).ordered
+      expect(subject).to receive(:upload_files).ordered
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "success")
+      expect(redis).to receive(:expire).with(@status_key, 86400)
+      expect(subject).to receive(:redis).ordered.twice.and_return(redis)
+
+      subject.perform(@status_key, @request_data)
+    end
+
+    it "can successfully process a font without conversion" do
+      expect(subject).to receive(:fetch_files).ordered
+      expect(subject).to receive(:process_files).ordered
+      expect(subject).to receive(:upload_metadata).ordered
+      expect(subject).to receive(:upload_files).ordered
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "success")
+      expect(redis).to receive(:expire).with(@status_key, 86400)
+      expect(subject).to receive(:redis).ordered.twice.and_return(redis)
+
+      subject.perform(@status_key, @no_convert)
+    end
+
+    it "can handle an error while processing the font" do
+      expect(subject).to receive(:fetch_files).ordered
+      expect(subject).to receive(:process_files).ordered.and_raise(RuntimeError)
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).ordered.twice.and_return(redis)
+
+      expect { subject.perform(@status_key, @request_data) }.to raise_exception(Exception)
+    end
+
+    it "can handle an error while retrieving the font data" do
+      expect(subject).to receive(:fetch_files).and_raise(FontBase::Error)
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+
+      expect { subject.perform(@status_key, @request_data) }.to raise_exception(FontBase::Error)
+    end
+
+    it "can handle an error while uploading the processed font metadata" do
+      expect(subject).to receive(:fetch_files).ordered
+      expect(subject).to receive(:process_files).ordered
+      expect(subject).to receive(:upload_metadata).and_raise(FontBase::Error)
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).ordered.twice.and_return(redis)
+
+      expect { subject.perform(@status_key, @request_data) }.to raise_exception(FontBase::Error)
+    end
+
+    it "can handle an error while uploading processed font data" do
+      expect(subject).to receive(:fetch_files).ordered
+      expect(subject).to receive(:process_files).ordered
+      expect(subject).to receive(:upload_metadata).ordered
+      expect(subject).to receive(:upload_files).ordered.and_raise(Aws::S3::Errors::ServiceError.new('message', 'service error'))
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).ordered.twice.and_return(redis)
+
+      expect { subject.perform(@status_key, @request_data) }.to raise_exception(Aws::S3::Errors::ServiceError)
+    end
+
+    it "can handle an error for an invalid request type" do
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+      bad_req_type = JSON.parse(@request_data)
+      bad_req_type['request_type'] = "desktop_processing_request"
+      expect { subject.perform(@status_key, bad_req_type) }.to raise_exception(RuntimeError)
+    end
+
+    it "can handle an error for a request without charset data" do
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+      bad_req = JSON.parse(@request_data)
+      bad_req.delete('charset')
+      expect { subject.perform(@status_key, bad_req) }.to raise_exception(RuntimeError, /No charset in JSON Request/)
+    end
+
+    it "can handle an error for a request without charset_id in the charset data" do
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+      bad_req = JSON.parse(@request_data)
+      bad_req['charset'].delete('charset_id')
+      expect { subject.perform(@status_key, bad_req) }.to raise_exception(RuntimeError, /No charset_id set in JSON Request's charset/)
+    end
+
+    it "can handle an error for a request without unicode in the charset data" do
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+      bad_req = JSON.parse(@request_data)
+      bad_req['charset'].delete('unicode')
+      expect { subject.perform(@status_key, bad_req) }.to raise_exception(RuntimeError, /No unicode set in JSON Request's charset/)
+    end
+
+    it "can handle an error for a request without features in the charset data" do
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+      bad_req = JSON.parse(@request_data)
+      bad_req['charset'].delete('features')
+      expect { subject.perform(@status_key, bad_req) }.to raise_exception(RuntimeError, /No features set in JSON Request's charset/)
+    end
+
+    it "can handle an error for a request without an fpv" do
+      redis = double("Redis")
+      expect(redis).to receive(:set).with(@status_key, "error")
+      expect(redis).to receive(:expire).with(@status_key, 30)
+      expect(subject).to receive(:redis).twice.and_return(redis)
+      bad_req = JSON.parse(@request_data)
+      bad_req.delete('fpv')
+      expect { subject.perform(@status_key, bad_req) }.to raise_exception(RuntimeError, /No fpv set on JSON Request/)
+    end
+  end
+
+  describe "fetching files" do
+    before(:each) do
+      FileUtils.mkdir_p(@directory)
+    end
+    after(:each) do
+      FileUtils.rm_r(@directory)
+    end
+    it "successfully handles a single PostScript file" do
+      client = double("FontBase::Client")
+      expect(client).to receive(:get_files).with(@font_base_id).and_return({"cff" => "cff-data"})
+      expect(subject).to receive(:client).and_return(client)
+      subject.fetch_files(@font_base_id, @directory)
+
+      expect(File.read(File.join(@directory, "original.otf"))).to eq "cff-data"
+    end
+
+    it "successfully handles a single TrueType file" do
+      client = double("FontBase::Client")
+      expect(client).to receive(:get_files).with(@font_base_id).and_return({"ttf" => "ttf-data"})
+      expect(subject).to receive(:client).and_return(client)
+      subject.fetch_files(@font_base_id, @directory)
+
+      expect(File.read(File.join(@directory, "original.ttf"))).to eq "ttf-data"
+    end
+
+    it "successfully handles a PostScript and TrueType file" do
+      client = double("FontBase::Client")
+      expect(client).to receive(:get_files).with(@font_base_id).and_return({"ttf" => "ttf-data", "cff" => "cff-data"})
+      expect(subject).to receive(:client).and_return(client)
+      subject.fetch_files(@font_base_id, @directory)
+
+      expect(File.read(File.join(@directory, "original.ttf"))).to eq "ttf-data"
+      expect(File.read(File.join(@directory, "original.otf"))).to eq "cff-data"
+    end
+  end
+
+  describe "processing files" do
+    before(:each) do
+      FileUtils.mkdir_p(@directory)
+    end
+    after(:each) do
+      FileUtils.rm_r(@directory)
+    end
+
+    it "successfully handles a PostScript file" do
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "postscript.otf"),
+                   File.join(@directory, "original.otf"))
+
+      parsed_data = JSON.parse(@request_data)
+      subject.process_files(@font_base_id, parsed_data['charset'], parsed_data['formats'], @directory)
+      iterator = FontProcessor::ProcessedFontIterator.new(@font_base_id, @charset_id, @fpv, @directory, true)
+      expect(iterator.valid?).to be true
+      expect(File.exist?(File.join(@directory, "charset-#{@charset_id}-otf.otf"))).to be true
+    end
+
+    it "successfully processes a TrueType file" do
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "truetype.otf"),
+                   File.join(@directory, "original.ttf"))
+
+      parsed_data = JSON.parse(@request_data)
+      subject.process_files(@font_base_id, parsed_data['charset'], parsed_data['formats'], @directory)
+      iterator = FontProcessor::ProcessedFontIterator.new(@font_base_id, @charset_id, @fpv, @directory, true)
+      expect(iterator.valid?).to be true
+      expect(File.exist?(File.join(@directory, "charset-#{@charset_id}-otf.ttf"))).to be true
+    end
+
+    it "successfully processes a PostScript file if given both" do
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "postscript.otf"),
+                   File.join(@directory, "original.otf"))
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "truetype.otf"),
+                   File.join(@directory, "original.ttf"))
+      parsed_data = JSON.parse(@request_data)
+      subject.process_files(@font_base_id, parsed_data['charset'], parsed_data['formats'], @directory)
+      iterator = FontProcessor::ProcessedFontIterator.new(@font_base_id, @charset_id, @fpv, @directory, true)
+      expect(iterator.valid?).to be true
+      expect(File.exist?(File.join(@directory, "charset-#{@charset_id}-otf.otf"))).to be true
+    end
+
+    it "successfully handles a PostScript file" do
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "postscript.otf"),
+                   File.join(@directory, "original.otf"))
+
+      parsed_data = JSON.parse(@request_data)
+      parsed_data['formats']['convert'] = false
+      subject.process_files(@font_base_id, parsed_data['charset'], parsed_data['formats'], @directory)
+      iterator = FontProcessor::ProcessedFontIterator.new(@font_base_id, @charset_id, @fpv, @directory, false)
+      expect(iterator.valid?).to be true
+      expect(File.exist?(File.join(@directory, "charset-#{@charset_id}-otf.otf"))).to be true
+    end
+
+    it "successfully subsets a Truetype file" do
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "truetype.otf"),
+                   File.join(@directory, "original.ttf"))
+
+      charset_data = {
+        "charset_id" => "3",
+        "features" => "NONE",
+        "unicode" => "32..32,65..90,97..122"
+      }
+      format_data = {
+        "process_original" => true,
+        "convert" => true,
+        "derivatives" => [ "dyna_base", "woff", "woff2", "inst", "svg", "swf" ]
+      }
+      subject.process_files(@font_base_id, charset_data, format_data, @directory, false)
+      iterator = FontProcessor::ProcessedFontIterator.new(@font_base_id, charset_data['charset_id'], @fpv, @directory, true)
+      expect(iterator.valid?).to be true
+      file = File.join(@directory, "charset-3-otf.ttf")
+      # process_files calls into generate_char_set, then into processor.generate_internal_char_set
+      # This method now automatically adds nb-space and soft-hyphen, so we need to expect
+      # U+A0 (160)
+      expect(FontProcessor::FontFile.new(file).unicode_ranges).to eq [32, 65..90, 97..122, 160]
+    end
+
+    it "throws MissingFilesException when neither are found" do
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "fixtures", "postscript.otf"), @directory)
+
+      expect { subject.select_preferred_original(@directory)}.to raise_error(FontProcessor::MissingFilesException)
+    end
+  end
+  describe "uploading metadata" do
+    it "successfully updates the metadata in fontbase" do
+      fake_font_file = double("FontFile", :unicode => "unicode data", :metrics => "metrics data", :names => "names data", :glyph_count => "1", :optical_size => "180", :features => "kern,size")
+      expected_metadata = {
+        :glyphs => "unicode data",
+        :metrics => "metrics data",
+        :names => "names data",
+        :glyph_count => "1",
+        :optical_size => "180",
+        :features => "kern,size"
+      }
+
+      client = double("FontBase::Client")
+      expect(client).to receive(:set_font_processing_version_attributes).with(@font_base_id, @fpv, expected_metadata).and_return({"ttf" => "ttf-data"})
+      expect(subject).to receive(:client).and_return(client)
+
+      subject.upload_metadata(@fpv, @font_base_id, fake_font_file)
+    end
+    it "successfully updates the metadata in fontbase with no optical size" do
+      fake_font_file = double("FontFile", :unicode => "unicode data", :metrics => "metrics data", :names => "names data", :glyph_count => "1", :optical_size => nil, :features => "kern")
+      expected_metadata = {
+          :glyphs => "unicode data",
+          :metrics => "metrics data",
+          :names => "names data",
+          :glyph_count => "1",
+          :optical_size => nil,
+          :features => "kern"
+      }
+
+      client = double("FontBase::Client")
+      expect(client).to receive(:set_font_processing_version_attributes).with(@font_base_id, @fpv, expected_metadata).and_return({"ttf" => "ttf-data"})
+      expect(subject).to receive(:client).and_return(client)
+
+      subject.upload_metadata(@fpv, @font_base_id, fake_font_file)
+    end
+  end
+  describe "uploading files" do
+    it "attempts to upload all valid files" do
+      iterator = [["file1", "key"]]
+      expect(FontProcessor::ProcessedFontIterator).to receive(:new).and_return(iterator)
+      expect(File).to receive(:binread).with("file1").and_return("")
+      expect_any_instance_of(Aws::S3::Client).to receive(:put_object).with(key: "key",
+                                                                           body: "",
+                                                                           bucket: FontProcessor::Config.s3_processed_bucket)
+      parsed_data = JSON.parse(@request_data)
+      subject.upload_files(parsed_data['fpv'], parsed_data['font_base_id'], parsed_data['charset']['charset_id'], parsed_data['formats'], @directory)
+    end
+  end
+end