webfontloader 1.4.0 → 1.4.1

data/spec/core/webfont_spec.js

@@ -0,0 +1,224 @@
+describe('WebFont', function () {
+  var WebFont = webfont.WebFont,
+      UserAgent = webfont.UserAgent,
+      BrowserInfo = webfont.BrowserInfo,
+      Font = webfont.Font,
+      FontModuleLoader = webfont.FontModuleLoader,
+      fontModuleLoader = null,
+      userAgent = null;
+
+  beforeEach(function () {
+    userAgent = new UserAgent('Firefox', '3.6', 'Gecko', '1.9.2', 'Macintosh', '10.6', undefined, new BrowserInfo(true, false, false));
+    fontModuleLoader = new FontModuleLoader();
+  });
+
+  describe('font load', function () {
+    var font = null,
+        testModule = null;
+
+    beforeEach(function () {
+      font = new WebFont(window, fontModuleLoader, userAgent);
+      font.addModule('test', function (conf, domHelper) {
+        testModule = new function () {
+          this.conf = conf;
+          this.domHelper = domHelper;
+          this.loadCalled = true;
+          this.supportUserAgentCalled = false;
+        };
+
+        testModule.load = function (onReady) {
+          this.loadCalled = true;
+          onReady([]);
+        };
+
+        testModule.supportUserAgent = function (ua, support) {
+          this.supportUserAgentCalled = true;
+          support(true);
+        };
+
+        return testModule;
+      });
+    });
+
+    it('should not start loading', function () {
+      expect(font.moduleFailedLoading_).toEqual(0);
+      expect(font.moduleLoading_).toEqual(0);
+    });
+
+    it('should fail to load a module', function () {
+      var loading = jasmine.createSpy('loading');
+
+      font.load({
+        test: {
+          somedata: 'in french a cow says meuh'
+        },
+        loading: loading
+      });
+
+      expect(font.moduleFailedLoading_).toEqual(1);
+      expect(font.moduleLoading_).toEqual(0);
+      expect(testModule).not.toBeNull();
+
+      expect(testModule.conf).not.toBeUndefined();
+      expect(testModule.conf).not.toBeNull();
+
+      expect(testModule.domHelper).not.toBeNull();
+      expect(testModule.domHelper).not.toBeUndefined();
+
+      expect(testModule.domHelper.getMainWindow()).toEqual(window);
+      expect(testModule.domHelper.getLoadWindow()).toEqual(window);
+
+      expect(testModule.conf.somedata).toEqual('in french a cow says meuh');
+      expect(testModule.loadCalled).toBe(true);
+      expect(testModule.supportUserAgentCalled).toBe(true);
+      expect(loading).toHaveBeenCalled();
+    });
+  });
+
+  describe('font load with context', function () {
+    var font = null,
+        testModule = null,
+        fakeMainWindow = {};
+
+    beforeEach(function () {
+      font = new WebFont(fakeMainWindow, fontModuleLoader, userAgent);
+      font.addModule('test', function (conf, domHelper) {
+        testModule = new function () {
+          this.domHelper = domHelper;
+        };
+        testModule.load = function () {};
+        testModule.supportUserAgent = function (ua, support) {
+          support(true);
+        };
+
+        return testModule;
+      });
+    });
+
+    it('should load with the correct context', function () {
+      font.load({
+        test: {
+          somedata: 'in french a cow says meuh'
+        },
+        context: window
+      });
+
+      expect(testModule.domHelper).not.toBeNull();
+      expect(testModule.domHelper).not.toBeUndefined();
+
+      expect(testModule.domHelper.getMainWindow()).toEqual(fakeMainWindow);
+      expect(testModule.domHelper.getLoadWindow()).toEqual(window);
+    });
+  });
+
+  describe('module failed to provide families and descriptions because it did not initialize properly', function () {
+    var webfont = null,
+        testModule = null,
+        font = null,
+        inactive = jasmine.createSpy('inactive'),
+        active = jasmine.createSpy('active');
+
+    beforeEach(function () {
+      font = new Font('Font1');
+      jasmine.Clock.useMock();
+      webfont = new WebFont(window, fontModuleLoader, new UserAgent('Firefox', '3.6', 'Gecko', '1.9.2', 'Macintosh', '10.6', undefined, new BrowserInfo(true, false)));
+      webfont.addModule('test', function (conf, domHelper) {
+        testModule = new function () {
+          this.conf = conf;
+          this.fonts = [];
+        };
+
+        testModule.getFontWatchRunnerCtor = function () {
+          function FakeFontWatchRunner(activeCallback, inactiveCallback) {
+            this.inactive = inactiveCallback;
+            this.active = activeCallback;
+          };
+
+          FakeFontWatchRunner.prototype.start = function () {
+            if (conf.id) {
+              this.active(font);
+            } else {
+              this.inactive(font);
+            }
+          };
+
+          return FakeFontWatchRunner;
+        };
+
+        testModule.supportUserAgent = function (userAgent, support) {
+          if (conf.id) {
+            // The monotype module only initializes font
+            // and description if there is a kit id.
+            this.fonts = [font];
+          }
+          support(true);
+        };
+        testModule.load = function (onReady) {
+          onReady(this.fonts);
+        };
+
+        return testModule;
+      });
+    });
+
+    it('should load with a project id', function () {
+      webfont.load({
+        test: {
+          id: 'hello world'
+        },
+        inactive: inactive,
+        active: active
+      });
+
+      jasmine.Clock.tick(1);
+
+      expect(testModule).not.toBeNull();
+      expect(active).toHaveBeenCalled();
+    });
+
+    it('should not load without a project id', function () {
+      webfont.load({
+        test: {
+        },
+        inactive: inactive,
+        active: active
+      });
+
+      jasmine.Clock.tick(1);
+
+      expect(testModule).not.toBeNull();
+      expect(inactive).toHaveBeenCalled();
+    });
+  });
+
+  describe('font inactive', function () {
+    var font = null,
+        testModule = null;
+
+    beforeEach(function () {
+      font = new WebFont(window, fontModuleLoader, new UserAgent('Firefox', '3.6', 'Gecko', '1.9.2', 'Macintosh', '10.6', undefined, new BrowserInfo(false, false, false)));
+      font.addModule('test', function (conf, domHelper) {
+        testModule = new function () {
+          this.conf = conf;
+          this.loadCalled = false;
+        };
+        testModule.load = function () {};
+        return testModule;
+      });
+    });
+
+    it('should load with the correct context', function () {
+      var inactive = jasmine.createSpy('inactive');
+
+      font.load({
+        test: {
+          somedata: 'in french a cow says meuh'
+        },
+        inactive: inactive
+      });
+
+      expect(testModule).toBeNull()
+      expect(inactive).toHaveBeenCalled();
+    });
+  });
+});

data/spec/custom/customcss_spec.js

@@ -1,5 +1,6 @@
 describe('CustomCss', function () {
-  var CustomCss = webfont.CustomCss;
+  var CustomCss = webfont.CustomCss,
+      FontFamily = webfont.FontFamily;
 
   describe('insert links correctly', function () {
     var fakeDomHelper = null,
@@ -30,7 +31,9 @@ describe('CustomCss', function () {
     it('should have loaded the families correctly', function () {
       expect(load.callCount).toEqual(1);
       expect(load.calls[0].args[0].length).toEqual(3);
-      expect(load.calls[0].args[0]).toEqual(['Font1', 'Font2', 'Font3']);
+      expect(load.calls[0].args[0][0].getName()).toEqual('Font1');
+      expect(load.calls[0].args[0][1].getName()).toEqual('Font2');
+      expect(load.calls[0].args[0][2].getName()).toEqual('Font3');
     });
   });
 });

data/spec/deps.js

@@ -1,26 +1,26 @@
 // This file was autogenerated by calcdeps.js
-goog.addDependency("../../src/ascender/ascender_script.js", ["webfont.AscenderScript"], []);
+goog.addDependency("../../src/ascender/ascender_script.js", ["webfont.AscenderScript"], ["webfont.Font"]);
 goog.addDependency("../../src/async_load.js", [], []);
 goog.addDependency("../../src/closure.js", [], []);
 goog.addDependency("../../src/core/browserinfo.js", ["webfont.BrowserInfo"], []);
 goog.addDependency("../../src/core/cssclassname.js", ["webfont.CssClassName"], []);
-goog.addDependency("../../src/core/cssfontfamilyname.js", ["webfont.CssFontFamilyName"], []);
 goog.addDependency("../../src/core/domhelper.js", ["webfont.DomHelper"], []);
 goog.addDependency("../../src/core/eventdispatcher.js", ["webfont.EventDispatcher"], ["webfont.CssClassName"]);
-goog.addDependency("../../src/core/font.js", ["webfont.WebFont"], ["webfont.DomHelper","webfont.EventDispatcher","webfont.FontWatcher"]);
-goog.addDependency("../../src/core/fontmoduleloader.js", ["webfont.FontModuleLoader"], []);
-goog.addDependency("../../src/core/fontruler.js", ["webfont.FontRuler"], ["webfont.CssFontFamilyName","webfont.FontVariationDescription"]);
-goog.addDependency("../../src/core/fontvariationdescription.js", ["webfont.FontVariationDescription"], []);
+goog.addDependency("../../src/core/font.js", ["webfont.Font"], []);
+goog.addDependency("../../src/core/fontmoduleloader.js", ["webfont.FontModuleLoader","webfont.FontModule","webfont.FontModuleFactory"], []);
+goog.addDependency("../../src/core/fontruler.js", ["webfont.FontRuler"], []);
 goog.addDependency("../../src/core/fontwatcher.js", ["webfont.FontWatcher"], ["webfont.FontWatchRunner"]);
-goog.addDependency("../../src/core/fontwatchrunner.js", ["webfont.FontWatchRunner"], ["webfont.FontRuler"]);
+goog.addDependency("../../src/core/fontwatchrunner.js", ["webfont.FontWatchRunner"], ["webfont.Font","webfont.FontRuler"]);
 goog.addDependency("../../src/core/initialize.js", ["webfont"], ["webfont.UserAgentParser","webfont.FontModuleLoader","webfont.WebFont"]);
+goog.addDependency("../../src/core/namespace.js", [], []);
 goog.addDependency("../../src/core/useragent.js", ["webfont.UserAgent"], []);
 goog.addDependency("../../src/core/useragentparser.js", ["webfont.UserAgentParser"], ["webfont.BrowserInfo","webfont.UserAgent"]);
-goog.addDependency("../../src/custom/customcss.js", ["webfont.CustomCss"], []);
-goog.addDependency("../../src/fontdeck/fontdeck_script.js", ["webfont.FontdeckScript"], ["webfont.FontVariationDescription"]);
-goog.addDependency("../../src/google/fontapiparser.js", ["webfont.FontApiParser"], ["webfont.FontVariationDescription"]);
+goog.addDependency("../../src/core/webfont.js", ["webfont.WebFont"], ["webfont.DomHelper","webfont.EventDispatcher","webfont.FontWatcher"]);
+goog.addDependency("../../src/custom/customcss.js", ["webfont.CustomCss"], ["webfont.Font"]);
+goog.addDependency("../../src/fontdeck/fontdeck_script.js", ["webfont.FontdeckScript"], ["webfont.Font"]);
+goog.addDependency("../../src/google/fontapiparser.js", ["webfont.FontApiParser"], ["webfont.Font"]);
 goog.addDependency("../../src/google/fontapiurlbuilder.js", ["webfont.FontApiUrlBuilder"], []);
 goog.addDependency("../../src/google/googlefontapi.js", ["webfont.GoogleFontApi"], ["webfont.FontApiUrlBuilder","webfont.FontApiParser","webfont.FontWatchRunner","webfont.LastResortWebKitFontWatchRunner"]);
-goog.addDependency("../../src/google/lastresortwebkitfontwatchrunner.js", ["webfont.LastResortWebKitFontWatchRunner"], ["webfont.FontRuler"]);
-goog.addDependency("../../src/monotype/monotype_script.js", ["webfont.MonotypeScript"], []);
-goog.addDependency("../../src/typekit/typekit_script.js", ["webfont.TypekitScript"], []);
+goog.addDependency("../../src/google/lastresortwebkitfontwatchrunner.js", ["webfont.LastResortWebKitFontWatchRunner"], ["webfont.Font","webfont.FontRuler"]);
+goog.addDependency("../../src/monotype/monotype_script.js", ["webfont.MonotypeScript"], ["webfont.Font"]);
+goog.addDependency("../../src/typekit/typekit_script.js", ["webfont.TypekitScript"], ["webfont.Font"]);

data/spec/fontdeck/fontdeckscript_spec.js

@@ -1,5 +1,6 @@
 describe('FontdeckScript', function () {
-  var FontdeckScript = webfont.FontdeckScript;
+  var FontdeckScript = webfont.FontdeckScript,
+      Font = webfont.Font;
 
   var configuration = {
     id: '2282'
@@ -83,9 +84,7 @@ describe('FontdeckScript', function () {
     it('should load correctly after calling the callback', function () {
       global.__webfontfontdeckmodule__['2282'](true, apiResponse);
 
-      expect(fontdeck.fontFamilies_).toEqual([apiResponse.fonts[0].name, apiResponse.fonts[1].name]);
-      expect(fontdeck.fontVariations_[apiResponse.fonts[0].name]).toEqual(['n4']);
-      expect(fontdeck.fontVariations_[apiResponse.fonts[1].name]).toEqual(['i7']);
+      expect(fontdeck.fonts_).toEqual([new Font(apiResponse.fonts[0].name), new Font(apiResponse.fonts[1].name, 'i7')]);
 
       expect(support).toHaveBeenCalled();
     });
@@ -103,8 +102,7 @@ describe('FontdeckScript', function () {
     });
 
     it('should not have loaded any fonts', function () {
-      expect(fontdeck.fontFamilies_).toEqual([]);
-      expect(fontdeck.fontVariations_).toEqual([]);
+      expect(fontdeck.fonts_).toEqual([]);
       expect(support).toHaveBeenCalled();
     });
   });

data/spec/fonts/sourcesansc.css

@@ -0,0 +1 @@
+@font-face{font-family:SourceSansC;src:url(sourcesans.eot?#iefix) format('embedded-opentype'),url(sourcesans.woff) format('woff'),url(sourcesans.otf) format('opentype'),url(sourcesans.ttf) format('truetype'),url(sourcesans.svg#source_sans_proregular) format('svg');font-weight:normal;font-style:normal;}

data/spec/fonts/sourcesanscbold.css

@@ -0,0 +1 @@
+@font-face{font-family:SourceSansC;src:url(sourcesanscbold.otf) format('opentype');font-weight:bold;font-style:normal;}

data/spec/google/fontapiparser_spec.js

@@ -1,5 +1,6 @@
 describe('FontApiParser', function () {
-  var FontApiParser = webfont.FontApiParser;
+  var FontApiParser = webfont.FontApiParser,
+      Font = webfont.Font;
 
   describe('parsed values are coherent', function () {
     var parser = null;
@@ -9,57 +10,23 @@ describe('FontApiParser', function () {
       parser.parse();
     });
 
-    it('should parse families correctly', function () {
-      var fontFamilies = parser.getFontFamilies();
-
-      expect(fontFamilies.length).toEqual(6);
-      expect(fontFamilies).toEqual([
-        'Tangerine',
-        'Droid Serif',
-        'Yanone Kaffeesatz',
-        'Cantarell',
-        'Exo',
-        'Lobster'
+    it('should parse fonts correctly', function () {
+      var fonts = parser.getFonts();
+
+      expect(fonts.length).toEqual(10);
+      expect(fonts).toEqual([
+        new Font('Tangerine', 'n4'),
+        new Font('Droid Serif', 'i7'),
+        new Font('Yanone Kaffeesatz', 'n2'),
+        new Font('Yanone Kaffeesatz', 'n3'),
+        new Font('Yanone Kaffeesatz', 'n4'),
+        new Font('Yanone Kaffeesatz', 'n7'),
+        new Font('Cantarell', 'i4'),
+        new Font('Cantarell', 'n7'),
+        new Font('Exo', 'i1'),
+        new Font('Lobster', 'n2')
       ]);
     });
-
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations();
-
-      var tangerine = variations['Tangerine'];
-      expect(tangerine).not.toBeNull();
-      expect(tangerine.length).toEqual(1);
-      expect(tangerine[0]).toEqual('n4');
-
-      var droidSerif = variations['Droid Serif'];
-      expect(droidSerif).not.toBeNull();
-      expect(droidSerif.length).toEqual(1);
-      expect(droidSerif[0]).toEqual('i7');
-
-      var yanoneKaffeesatz = variations['Yanone Kaffeesatz'];
-      expect(yanoneKaffeesatz).not.toBeNull();
-      expect(yanoneKaffeesatz.length).toEqual(4);
-      expect(yanoneKaffeesatz[0]).toEqual('n2');
-      expect(yanoneKaffeesatz[1]).toEqual('n3');
-      expect(yanoneKaffeesatz[2]).toEqual('n4');
-      expect(yanoneKaffeesatz[3]).toEqual('n7');
-
-      var cantarell = variations['Cantarell'];
-      expect(cantarell).not.toBeNull();
-      expect(cantarell.length).toEqual(2);
-      expect(cantarell[0]).toEqual('i4');
-      expect(cantarell[1]).toEqual('n7');
-
-      var exo = variations['Exo'];
-      expect(exo).not.toBeNull();
-      expect(exo.length).toEqual(1);
-      expect(exo[0]).toEqual('i1');
-
-      var lobster = variations['Lobster'];
-      expect(lobster).not.toBeNull();
-      expect(lobster.length).toEqual(1);
-      expect(lobster[0]).toEqual('n2');
-    });
   });
 
   describe('mix of numeric weight and style', function () {
@@ -70,23 +37,16 @@ describe('FontApiParser', function () {
       parser.parse();
     });
 
-    it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
-
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Nobile');
-    });
-
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          nobile = variations['Nobile'];
+    it('should parse fonts correctly', function () {
+      var fonts = parser.getFonts();
 
-      expect(nobile).not.toBeNull();
-      expect(nobile.length).toEqual(4);
-      expect(nobile[0]).toEqual('i7');
-      expect(nobile[1]).toEqual('n7');
-      expect(nobile[2]).toEqual('i2');
-      expect(nobile[3]).toEqual('n4');
+      expect(fonts.length).toEqual(4);
+      expect(fonts).toEqual([
+        new Font('Nobile', 'i7'),
+        new Font('Nobile', 'n7'),
+        new Font('Nobile', 'i2'),
+        new Font('Nobile', 'n4')
+      ]);
     });
   });
 
@@ -99,19 +59,10 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
-
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Nobile');
-    });
+      var fonts = parser.getFonts();
 
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          nobile = variations['Nobile'];
-
-      expect(nobile).not.toBeNull();
-      expect(nobile.length).toEqual(1);
-      expect(nobile[0]).toEqual('n4');
+      expect(fonts.length).toEqual(1);
+      expect(fonts[0]).toEqual(new Font('Nobile', 'n4'));
     });
   });
 
@@ -124,19 +75,10 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
+      var fonts = parser.getFonts();
 
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Nobile');
-    });
-
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          nobile = variations['Nobile'];
-
-      expect(nobile).not.toBeNull();
-      expect(nobile.length).toEqual(1);
-      expect(nobile[0]).toEqual('n4');
+      expect(fonts.length).toEqual(1);
+      expect(fonts[0]).toEqual(new Font('Nobile', 'n4'));
     });
   });
 
@@ -149,19 +91,10 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
-
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Cantarell');
-    });
+      var fonts = parser.getFonts();
 
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          cantarell = variations['Cantarell'];
-
-      expect(cantarell).not.toBeNull();
-      expect(cantarell.length).toEqual(1);
-      expect(cantarell[0]).toEqual('n4');
+      expect(fonts.length).toEqual(1);
+      expect(fonts[0]).toEqual(new Font('Cantarell', 'n4'));
     });
 
     it('should parse pick test strings correctly', function () {
@@ -182,19 +115,10 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
+      var fonts = parser.getFonts();
 
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Cantarell');
-    });
-
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          cantarell = variations['Cantarell'];
-
-      expect(cantarell).not.toBeNull();
-      expect(cantarell.length).toEqual(1);
-      expect(cantarell[0]).toEqual('n4');
+      expect(fonts.length).toEqual(1);
+      expect(fonts[0]).toEqual(new Font('Cantarell', 'n4'));
     });
 
     it('should parse pick test strings correctly', function () {
@@ -215,20 +139,13 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
-
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Cantarell');
-    });
+      var fonts = parser.getFonts();
 
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          cantarell = variations['Cantarell'];
-
-      expect(cantarell).not.toBeNull();
-      expect(cantarell.length).toEqual(2);
-      expect(cantarell[0]).toEqual('n4');
-      expect(cantarell[1]).toEqual('n7');
+      expect(fonts.length).toEqual(2);
+      expect(fonts).toEqual([
+        new Font('Cantarell', 'n4'),
+        new Font('Cantarell', 'n7')
+      ]);
     });
 
     it('should parse pick test strings correctly', function () {
@@ -249,19 +166,10 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
+      var fonts = parser.getFonts();
 
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Hanuman');
-    });
-
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          hanuman = variations['Hanuman'];
-
-      expect(hanuman).not.toBeNull();
-      expect(hanuman.length).toEqual(1);
-      expect(hanuman[0]).toEqual('n4');
+      expect(fonts.length).toEqual(1);
+      expect(fonts[0]).toEqual(new Font('Hanuman', 'n4'));
     });
 
     it('should parse pick test strings correctly', function () {
@@ -282,19 +190,10 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var families = parser.getFontFamilies();
-
-      expect(families.length).toEqual(1);
-      expect(families[0]).toEqual('Hanuman');
-    });
+      var fonts = parser.getFonts();
 
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations(),
-          hanuman = variations['Hanuman'];
-
-      expect(hanuman).not.toBeNull();
-      expect(hanuman.length).toEqual(1);
-      expect(hanuman[0]).toEqual('n4');
+      expect(fonts.length).toEqual(1);
+      expect(fonts[0]).toEqual(new Font('Hanuman', 'n4'));
     });
 
     it('should parse pick test strings correctly', function () {
@@ -315,34 +214,15 @@ describe('FontApiParser', function () {
     });
 
     it('should parse families correctly', function () {
-      var fontFamilies = parser.getFontFamilies();
-
-      expect(fontFamilies.length).toEqual(3);
-      expect(fontFamilies).toEqual([
-        'Erica One',
-        'Droid Serif',
-        'Yanone Kaffeesatz'
+      var fonts = parser.getFonts();
+
+      expect(fonts.length).toEqual(4);
+      expect(fonts).toEqual([
+        new Font('Erica One', 'n4'),
+        new Font('Droid Serif', 'n4'),
+        new Font('Yanone Kaffeesatz', 'n4'),
+        new Font('Yanone Kaffeesatz', 'n7')
       ]);
     });
-
-    it('should parse variations correctly', function () {
-      var variations = parser.getVariations();
-
-      var ericaOne = variations['Erica One'];
-      expect(ericaOne).not.toBeNull();
-      expect(ericaOne.length).toEqual(1);
-      expect(ericaOne[0]).toEqual('n4');
-
-      var droidSerif = variations['Droid Serif'];
-      expect(droidSerif).not.toBeNull();
-      expect(droidSerif.length).toEqual(1);
-      expect(droidSerif[0]).toEqual('n4');
-
-      var yanoneKaffeesatz = variations['Yanone Kaffeesatz'];
-      expect(yanoneKaffeesatz).not.toBeNull();
-      expect(yanoneKaffeesatz.length).toEqual(2);
-      expect(yanoneKaffeesatz[0]).toEqual('n4');
-      expect(yanoneKaffeesatz[1]).toEqual('n7');
-    });
   });
 });