Added default values to the dictionary and warn about missing keys

src/core/index.js

@@ -425,7 +425,7 @@ export function emitAuthorizationErrorEvent(m, error) {
 }
 
 export function emitUnrecoverableErrorEvent(m, error) {
-  emitEvent(m, "unrecoverable_error", error)
+  emitEvent(m, "unrecoverable_error", error);
 }
 
 export function showBadge(m) {

src/i18n.js

@@ -27,6 +27,7 @@ export function group(m, keyPath) {
 export function initI18n(m) {
   const language = l.ui.language(m);
   const overrides = l.ui.dict(m);
+  const defaultDictionary = Immutable.fromJS(enDictionary);
 
   let base = languageDictionaries[language] || Map({});
 
@@ -37,24 +38,36 @@ export function initI18n(m) {
       successFn: (m, result) => {
         registerLanguageDictionary(language, result);
 
+        const overrided = Immutable.fromJS(result).mergeDeep(overrides);
+
+        assertLanguage(m, overrided.toJS(), enDictionary);
+
         return set(
           m,
           "strings",
-          languageDictionaries[language].mergeDeep(overrides)
+          defaultDictionary.mergeDeep(overrided)
         );
       }
     });
+  } else {
+    assertLanguage(m, base.toJS(), enDictionary);
   }
 
-  if (!base.has("title")) {
-    base = base.set("title", enDictionary.title);
-  }
+  base = defaultDictionary.mergeDeep(base).mergeDeep(overrides);
 
-  if (!base.has("unrecoverableError")) {
-    base = base.set("unrecoverableError", enDictionary.unrecoverableError);
-  }
+  return set(m, "strings", base);
+}
 
-  return set(m, "strings", base.mergeDeep(overrides));
+function assertLanguage(m, language, base, path = "") { 
+  Object.keys(base).forEach( key => {
+    if (!language.hasOwnProperty(key)) {
+      l.warn(m, `language does not have property ${path}${key}`);
+    } else {
+      if (typeof base[key] === 'object') {
+        assertLanguage(m, language[key], base[key], `${path}${key}.`);
+      }
+    }
+  });
 }
 
 // sync

test/i18n.test.js

@@ -0,0 +1,54 @@
+import expect from 'expect.js';
+import Immutable from 'immutable';
+import {initI18n} from '../src/i18n';
+import { go } from '../src/sync';
+import { swap, setEntity, updateEntity, observe } from '../src/store/index';
+import { dataFns } from '../src/utils/data_utils';
+
+import enDictionary from '../src/i18n/en';
+import esDictionary from '../src/i18n/es';
+
+const core = dataFns(["core"]);
+
+describe("load i18n configuration", function() {
+
+  it("should merge and warn missing keys", function(done) {
+
+    const id = 1;
+
+    var m = Immutable.fromJS({
+      languageBaseUrl: "https://cdn.auth0.com",
+      ui: {
+        disableWarnings: true,
+        language: "es"
+      }
+    });
+
+    go(id);
+
+    observe("test", id, (m) => { 
+      if (m.getIn(['sync', 'i18n', 'syncStatus']) === 'ok') {
+        assertLanguage(m.getIn(['i18n', 'strings']).toJS(), enDictionary, esDictionary)
+        done();
+      }
+    });
+
+    m = core.init(id, m);
+
+    m = initI18n(m);
+
+    m = swap(setEntity, "lock", id, m);
+  });
+});
+
+function assertLanguage(language, en, es) { 
+  Object.keys(en).forEach( (key) => {
+    expect(language).to.have.property(key);
+    if (typeof en[key] === 'object') {
+      assertLanguage(language[key], en[key], es[key]);
+    }
+    else {
+      expect([en[key], es[key]]).to.contain(language[key]);
+    }
+  });
+}