Merge pull request #23 from Exabyte-io/fix/SOF-6197

fix/SOF-6197

Author: timurbazhirov

package-lock.json

@@ -1,9 +1,9 @@
 import { JSONSchemaFormDataProvider } from "./json_schema_provider";
 import {
-    ApplicationContextMixinBuilder,
+    ApplicationContextMixin,
     JobContextMixin,
-    MaterialContextMixinBuilder,
-    MaterialsContextMixinBuilder,
+    MaterialContextMixin,
+    MaterialsContextMixin,
     MaterialsSetContextMixin,
     MethodDataContextMixin,
     WorkflowContextMixin,
@@ -18,9 +18,9 @@ export {
     JobContextPickKeysForMixin,
     JSONSchemaFormDataProvider,
     WorkflowContextPickKeysForMixin,
-    ApplicationContextMixinBuilder,
-    MaterialContextMixinBuilder,
-    MaterialsContextMixinBuilder,
+    ApplicationContextMixin,
+    MaterialContextMixin,
+    MaterialsContextMixin,
     MaterialsSetContextMixin,
     MethodDataContextMixin,
     JobContextMixin,

src/context/index.js

@@ -3,28 +3,31 @@ import CryptoJS from "crypto-js";
 
 import { compareEntitiesInOrderedSetForSorting } from "../entity/set/ordered/utils";
 
-export const ApplicationContextMixinBuilder = (applicationCls) => (superclass) =>
+export const ApplicationContextMixin = (superclass) =>
     class extends superclass {
         constructor(config) {
             super(config);
-            if (!applicationCls)
-                throw Error("ApplicationContextMixinBuilder: applicationCls is undefined");
+            if (!this.constructor.applicationCls)
+                throw Error("ApplicationContextMixin: applicationCls is undefined");
             this._application =
-                (config.context && config.context.application) || applicationCls.createDefault();
+                (config.context && config.context.application) ||
+                this.constructor.applicationCls.createDefault();
         }
 
         get application() {
             return this._application;
         }
     };
 
-export const MaterialContextMixinBuilder = (materialCls) => (superclass) =>
+export const MaterialContextMixin = (superclass) =>
     class extends superclass {
         constructor(config) {
             super(config);
-            if (!materialCls) throw Error("MaterialContextMixinBuilder: materialCls is undefined");
+            if (!this.constructor.materialCls) {
+                throw Error("MaterialContextMixin: materialCls is undefined");
+            }
             this._material = config.context && config.context.material;
-            if (!this._material) this._material = materialCls.createDefault();
+            if (!this._material) this._material = this.constructor.materialCls.createDefault();
             this.updateMaterialHash();
         }
 
@@ -74,14 +77,18 @@ export const MaterialsSetContextMixin = (superclass) =>
         }
     };
 
-export const MaterialsContextMixinBuilder = (materialCls) => (superclass) =>
+export const MaterialsContextMixin = (superclass) =>
     class extends superclass {
         constructor(config) {
             super(config);
             const materials = this.config.context && this.config.context.materials;
-            if (!materialCls) throw Error("MaterialsContextMixinBuilder: materialCls is undefined");
+            if (!this.constructor.materialCls) {
+                throw Error("MaterialsContextMixin: materialCls is undefined");
+            }
             this._materials =
-                materials && materials.length ? materials : [materialCls.createDefault()];
+                materials && materials.length
+                    ? materials
+                    : [this.constructor.materialCls.createDefault()];
         }
 
         get materials() {

src/context/mixins.js

@@ -0,0 +1,60 @@
+import { expect } from "chai";
+import { mix } from "mixwith";
+
+import { ApplicationContextMixin, MaterialContextMixin } from "../src/context/mixins";
+import { InMemoryEntity } from "../src/entity";
+
+class MockMaterial {
+    static createDefault() {
+        return "defaultMockMaterial";
+    }
+}
+
+class SpecificMockMaterial {
+    static createDefault() {
+        return "defaultSpecificMockMaterial";
+    }
+}
+
+class MockApplication {
+    static createDefault() {
+        return "defaultMockApplication";
+    }
+}
+
+class SpecificMockApplication {
+    static createDefault() {
+        return "defaultSpecificMockApplication";
+    }
+}
+
+class ProviderEntity extends mix(InMemoryEntity).with(
+    MaterialContextMixin,
+    ApplicationContextMixin,
+) {
+    static materialCls = MockMaterial;
+
+    static applicationCls = MockApplication;
+}
+
+class DerivedProviderEntity extends ProviderEntity {
+    static materialCls = SpecificMockMaterial;
+
+    static applicationCls = SpecificMockApplication;
+}
+
+describe("Material & Application ContextMixin", () => {
+    const config = {};
+
+    it("uses static entity class", () => {
+        const provider = new ProviderEntity(config);
+        expect(provider.material).to.be.equal("defaultMockMaterial");
+        expect(provider.application).to.be.equal("defaultMockApplication");
+    });
+
+    it("uses static entity class from derived class", () => {
+        const provider = new DerivedProviderEntity(config);
+        expect(provider.material).to.be.equal("defaultSpecificMockMaterial");
+        expect(provider.application).to.be.equal("defaultSpecificMockApplication");
+    });
+});