dyo-tools 0.2.0 → 0.3.2

package/test/core/DTModule.spec.ts

@@ -0,0 +1,138 @@
+import {DTComponent, DTModule} from "../../src";
+import {mockOverriddenMethods} from "./DTComponent.double";
+import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
+import {DTModuleTest, IDTest, KeyTest} from "./DTModule.double";
+import MockedFunction = jest.MockedFunction;
+
+/** ****************** MOCK DEPENDENCIES
+ * Dependencies used by the component are mocked with Jest
+ * **** */
+jest.mock('../../src/core/DTComponent');
+jest.mock('../../src/core/DTError');
+// Add specific mock for inherited methods to have a basic implementation
+mockOverriddenMethods(DTComponent);
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsModule', () => {
+  let moduleTest: DTModuleTest;
+
+  beforeEach(() => {
+    moduleTest = new DTModuleTest();
+    moduleTest.th_set_id(IDTest);
+    moduleTest.th_set_key(KeyTest);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('inheritance', () => {
+    test('check good inheritance for class', () => {
+      expect(DTModule.prototype instanceof DTComponent).toBeTruthy();
+    });
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "action"', () => {
+      expect(moduleTest.th_get_componentType()).toBe('module');
+    });
+  });
+
+  describe('constructor()', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('simple creation with key', () => {
+      const newModule = new DTModuleTest(KeyTest);
+      const parentConstructorMock = (DTComponent.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
+
+      expect(parentConstructorMock.calls.length).toBe(1);
+      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
+
+      expect(newModule.th_get_enabled()).toStrictEqual(true);
+    });
+  });
+
+  describe('getMaster()', () => {
+    test('call get context with master accessor', () => {
+      moduleTest.getMaster();
+
+      expect((moduleTest.getContext as any).mock.calls.length).toBe(1);
+      expect((moduleTest.getContext as any).mock.calls[0][0]).toBe('master');
+    });
+  });
+
+  describe('isEnabled()', () => {
+    test('return true if the module is enabled', () => {
+      const enabledModule = moduleTest.isEnabled();
+
+      expect(enabledModule).toBe(true);
+    });
+
+    test('return false if the module is disabled', () => {
+      moduleTest.th_set_enabled(false);
+
+      const enabledModule = moduleTest.isEnabled();
+
+      expect(enabledModule).toBe(false);
+    });
+  });
+
+  describe('enable()', () => {
+    test('change enable to true', () => {
+      moduleTest.th_set_enabled(false);
+
+      moduleTest.enable();
+
+      expect(moduleTest.th_get_enabled()).toBe(true);
+    });
+  });
+
+  describe('disable()', () => {
+    test('change enable to false', () => {
+      moduleTest.th_set_enabled(true);
+
+      moduleTest.disable();
+
+      expect(moduleTest.th_get_enabled()).toBe(false);
+    });
+  });
+
+  describe('toString()', () => {
+    test('string output standard', () => {
+      const toStringAction = moduleTest.toString();
+
+      expect(toStringAction).toBe(`Component ${KeyTest} - Type: Module`);
+    });
+
+    test('string output standard when disabled', () => {
+      moduleTest.th_set_enabled(false);
+
+      const toStringAction = moduleTest.toString();
+
+      expect(toStringAction).toBe(`Component ${KeyTest} - Type: Module - Disabled`);
+    });
+  });
+
+  describe('toObject()', () => {
+    test('toObject output standard', () => {
+      const toObjectAction: any = moduleTest.toObject();
+
+      expect(Object.keys(toObjectAction)).toStrictEqual(['id', 'key', 'type', 'enabled']);
+      expect(toObjectAction.id).toBe(IDTest);
+      expect(toObjectAction.key).toBe(KeyTest);
+      expect(toObjectAction.type).toBe('module');
+      expect(toObjectAction.enabled).toBe(true);
+    });
+
+    test('toObject output standard when disabled', () => {
+      moduleTest.th_set_enabled(false);
+
+      const toObjectAction: any = moduleTest.toObject();
+
+      expect(Object.keys(toObjectAction)).toStrictEqual(['id', 'key', 'type', 'enabled']);
+      expect(toObjectAction.enabled).toBe(false);
+    });
+  });
+});

package/test/core/copy.spec.ts

@@ -3,7 +3,7 @@ import {
 } from '@jest/globals';
 import { DTBunch, DTElement, DTPlayer } from '../../src';
 import { DTComponentStub } from './DTComponent.double';
-import { DTPlayerStub } from './DTPlayer.double';
+import {OwnerTest} from './DTComponentPhysical.double';
 import {
   BunchMetaData, HaileiMetaData, IMetaDataTest, PlayerMetaData,
 } from './DTComponentWithMeta.double';
@@ -44,7 +44,7 @@ describe('Inherited method copy', () => {
       });
 
       bunch.setContext(new DTComponentStub());
-      bunch.setOwner(new DTPlayerStub());
+      bunch.setOwner(OwnerTest);
 
       const bunchCopy = bunch.copy();
       jest.spyOn(bunchCopy, 'getContext').mockImplementation(function () {
@@ -62,7 +62,7 @@ describe('Inherited method copy', () => {
       const copiedOptions = {
         inheritOwner: true,
         replaceIndex: true,
-        virtualContext: true,
+        virtualContainer: true,
       };
       const bunch = new DTBunch('', [], copiedOptions);
       jest.spyOn(bunch, 'getManyMeta').mockImplementation(() => BunchMetaData);
@@ -114,7 +114,7 @@ describe('Inherited method copy', () => {
       jest.spyOn(items[0], 'copy');
       jest.spyOn(items[1], 'copy');
       jest.spyOn(items[2], 'copy');
-      const bunch = new DTBunch<DTElement<IMetaDataTest>, IMetaDataTest>(KeyTest, items, { virtualContext: true });
+      const bunch = new DTBunch<DTElement<IMetaDataTest>, IMetaDataTest>(KeyTest, items, { virtualContainer: true });
 
       const bunchCopy = bunch.copy();
 
@@ -154,6 +154,22 @@ describe('Inherited method copy', () => {
       expect(elementCopy.getContext()).toBeUndefined();
     });
 
+    test('copy an element - not copy container', () => {
+      const element = new DTElement(KeyTest);
+      jest.spyOn(element, 'setContainer').mockImplementation(function (container) {
+        this._container = container;
+      });
+
+      element.setContext(new DTComponentStub());
+
+      const elementCopy = element.copy();
+      jest.spyOn(elementCopy, 'getContainer').mockImplementation(function () {
+        return this._container;
+      });
+
+      expect(elementCopy.getContainer()).toBeUndefined();
+    });
+
     test('copy an element - copy meta-data and options', () => {
       const element = new DTElement(KeyTest, { errors: true });
       jest.spyOn(element, 'getManyMeta').mockImplementation(() => HaileiMetaData);

package/test/{core/DTPlayer.double.ts → libs/player/DTPlayer.element.double.ts}

@@ -1,18 +1,20 @@
-import {DTPlayer} from '../../src';
-import {IMetaDataTest} from './DTComponentWithMeta.double';
+import {DTPlayer} from '../../../src';
 
 /******************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
  * *****/
 export const IDTest = 'DTPlayer-id-1234567';
 export const KeyTest = 'DTPlayer-key-1234567';
-export const toStringTest = 'DTPlayer Stub toString';
+
+// Specific elements constants
+export const KeyTest1 = 'DTPlayer-key-1234567-1';
+export const KeyTest2 = 'DTPlayer-key-1234567-2';
 
 /******************** HELPER TEST CLASS
  * Helper test class, inherits the main component
  * Providing methods to property access and other facilities, in order to avoid using class methods
  * *****/
-export class DTPlayerTest extends DTPlayer<IMetaDataTest> {
+export class DTPlayerTest extends DTPlayer {
   th_get_id(): string {
     return this._id;
   }
@@ -29,36 +31,25 @@ export class DTPlayerTest extends DTPlayer<IMetaDataTest> {
     this._key = key;
   }
 
-  th_get_componentType(): string {
-    return this._componentType;
-  }
-
-  th_set_meta(meta: IMetaDataTest): void {
-    this._meta = meta;
+  th_get_domain(): string {
+    return this._domain;
   }
 }
 
-/******************** STUB CLASS
+/** ****************** STUB CLASS
  * Stub class, for using in other component
- * *****/
-export class DTPlayerStub extends DTPlayer<{}> {
-  constructor() {
-    super();
+ * **** */
+export class DTPlayerStub extends DTPlayerTest {
+  constructor(key: string) {
+    super(key);
+    this._key = key;
     this._id = IDTest;
-    this._key = KeyTest;
-  }
-
-  getKey(): string {
-    return KeyTest;
   }
 
   getId(): string {
     return IDTest;
   }
-
-  toString(): string {
-    return toStringTest;
-  }
 }
 
 
+

package/test/libs/player/DTPlayer.element.spec.ts

@@ -0,0 +1,28 @@
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
+import {DTPlayerTest} from "./DTPlayer.element.double";
+import {DTElement, DTPlayer} from "../../../src";
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsPlayerElement', () => {
+    let playerTest: DTPlayerTest;
+
+    beforeEach(() => {
+        playerTest = new DTPlayerTest();
+    });
+
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe('inheritance', () => {
+        test('check good inheritance for class', () => {
+            expect(DTPlayer.prototype instanceof DTElement).toBeTruthy();
+        });
+    });
+
+    describe('_domain', () => {
+        test('domain must be "player"', () => {
+            expect(playerTest.th_get_domain()).toBe('player');
+        });
+    });
+});

package/test/libs/player/DTPlayer.manager.double.ts

@@ -0,0 +1,92 @@
+import {DTPlayer, DTPlayerManager} from '../../../src';
+import {DTAcceptedMetaData, DTManagerItemsType, DTManagerOptions} from "../../../src/types";
+import {DTBunchStubLibrary} from "../../core/DTBunch.double";
+import {DTPlayerStub} from "./DTPlayer.element.double";
+
+/******************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * *****/
+export const IDTest = 'DTPlayerManager-id-1234567';
+export const KeyTest = 'DTPlayerManager-key-1234567';
+
+/******************** HELPER TEST CLASS
+ * Helper test class, inherits the main component
+ * Providing methods to property access and other facilities, in order to avoid using class methods
+ * *****/
+export class DTPlayerManagerTest extends DTPlayerManager {
+  th_get_id(): string {
+    return this._id;
+  }
+
+  th_set_id(id: string): void {
+    this._id = id;
+  }
+
+  th_get_key(): string {
+    return this._key;
+  }
+
+  th_set_key(key: string): void {
+    this._key = key;
+  }
+
+  th_get_domain(): string {
+    return this._domain;
+  }
+
+  th_get_items(): any {
+    return this._items;
+  }
+
+  th_set_items(items: DTManagerItemsType<DTPlayer<DTAcceptedMetaData>>): void {
+    this._items = items;
+  }
+
+  th_get_single_item(id: string): any {
+    return this._items[id];
+  }
+
+  th_get_scopes(): any {
+    return this._scopes;
+  }
+
+  th_set_scopes(scopes: any): void {
+    this._scopes = scopes;
+  }
+
+  th_get_library(): any {
+    return this._library;
+  }
+
+  th_set_library(library: any): void {
+    this._library = library;
+  }
+
+  th_get_options(): DTManagerOptions {
+    return this._options;
+  }
+}
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */
+export const populateManager = (manager: DTPlayerManagerTest): DTPlayerManagerTest => {
+  const mockedElements = [];
+
+  // Create players Stubs
+  let nbPlayers = 3;
+  while (nbPlayers > 0) {
+    const player = new DTPlayerStub(`player${nbPlayers}`);
+    mockedElements.push(player);
+
+    nbPlayers--;
+  }
+
+  // Library
+  manager.th_set_library(new DTBunchStubLibrary(mockedElements));
+
+  return manager;
+}
+
+
+

package/test/libs/player/DTPlayer.manager.spec.ts

@@ -0,0 +1,178 @@
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
+import {DTManager, DTPlayer, DTPlayerManager} from "../../../src";
+import {DTPlayerManagerTest} from "./DTPlayer.manager.double";
+import {DTPlayerStub, IDTest, KeyTest, KeyTest1, KeyTest2} from "./DTPlayer.element.double";
+import {managerDefaultOptions} from "../../../src/constants";
+
+/** ****************** MOCK DEPENDENCIES
+ * Dependencies used by the component are mocked with Jest
+ * **** */
+jest.mock('../../../src/libs/player/DTPlayer.element');
+jest.mock('../../../src/core/DTBunch');
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsPlayerManager', () => {
+    let playerManagerTest: DTPlayerManagerTest;
+
+    beforeEach(() => {
+        playerManagerTest = new DTPlayerManagerTest();
+    });
+
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe('inheritance', () => {
+        test('check good inheritance for class', () => {
+            expect(DTPlayerManager.prototype instanceof DTManager).toBeTruthy();
+        });
+    });
+
+    describe('_domain', () => {
+        test('domain must be "player"', () => {
+            expect(playerManagerTest.th_get_domain()).toBe('player');
+        });
+    });
+
+    describe('constructor()', () => {
+        beforeEach(() => {
+            (DTPlayer.prototype.getKey as any).mockImplementation(function() {
+                return this._key;
+            })
+        });
+
+        test('creation simple empty manager', () => {
+            const newPlayerManager = new DTPlayerManagerTest();
+
+            expect(newPlayerManager.th_get_key()).toBe('player');
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+            expect(newPlayerManager.th_get_scopes()).toStrictEqual(['default', 'virtual']);
+            expect(newPlayerManager.th_get_library()).toBeDefined();
+        });
+
+        test('creation with simple configuration - player number', () => {
+            const configuration = {
+                players: 3
+            }
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+
+            // Check creation of 3 DTPlayer
+            let calls = 3;
+            expect((DTPlayer.prototype.constructor as any).mock.calls.length).toBe(calls);
+            while (calls > 0) {
+                expect((DTPlayer.prototype.constructor as any).mock.calls[calls - 1][0]).toBe(`player${calls}`);
+                calls--;
+            }
+
+            // Check adding 3 DTPlayer to library
+            expect((newPlayerManager.th_get_library().add as any).mock.calls.length).toBe(3);
+        });
+
+        test('creation with simple configuration - player array', () => {
+            const configuration = {
+                players: [
+                    new DTPlayerStub(KeyTest),
+                    new DTPlayerStub(KeyTest1),
+                    new DTPlayerStub(KeyTest2),
+                ]
+            }
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls.length).toBe(1);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0].length).toBe(3);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0][0].th_get_key()).toBe(KeyTest);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0][1].th_get_key()).toBe(KeyTest1);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0][2].th_get_key()).toBe(KeyTest2);
+        });
+
+        test('creation with simple configuration - invalid player number', () => {
+            const configuration = {
+                players: -3
+            }
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+
+            // No creation and adding
+            expect((DTPlayer.prototype.constructor as any).mock.calls.length).toBe(0);
+            expect((newPlayerManager.th_get_library().add as any).mock.calls.length).toBe(0);
+        });
+
+        test('creation with simple configuration - errors manager option', () => {
+            const configuration = {
+                errors: true
+            };
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_options()).toStrictEqual({
+                ...managerDefaultOptions,
+                errors: true
+            });
+        });
+    });
+
+    describe('getPlayer()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call get() of library', () => {
+            const library = playerManagerTest.th_get_library();
+
+            playerManagerTest.getPlayer(IDTest);
+
+            expect((library.get).mock.calls.length).toBe(1);
+            expect((library.get).mock.calls[0][0]).toBe(IDTest);
+        });
+    });
+
+    describe('addPlayer()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call add() of library', () => {
+            const library = playerManagerTest.th_get_library();
+            const playerToAdd = new DTPlayerStub(KeyTest);
+
+            playerManagerTest.addPlayer(playerToAdd);
+
+            expect((library.add).mock.calls.length).toBe(1);
+            expect((library.add).mock.calls[0][0]).toStrictEqual(playerToAdd);
+        });
+    });
+
+    describe('removePlayer()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call remove() of library', () => {
+            const library = playerManagerTest.th_get_library();
+
+            playerManagerTest.removePlayer(IDTest);
+
+            expect((library.remove).mock.calls.length).toBe(1);
+            expect((library.remove).mock.calls[0][0]).toBe(IDTest);
+        });
+    });
+
+    describe('findPlayers()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call find() of library', () => {
+            const library = playerManagerTest.th_get_library();
+            const testFilters = { id: { $eq: IDTest }, key: { $ne: KeyTest } };
+
+            playerManagerTest.findPlayers(testFilters);
+
+            expect((library.find).mock.calls.length).toBe(1);
+            expect((library.find).mock.calls[0][0]).toStrictEqual(testFilters);
+        });
+    });
+});

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Flaya24
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/cucumber.js

@@ -1,9 +0,0 @@
-module.exports = {
-    default: {
-        parallel: 2,
-        format: ['html:cucumber-report.html'],
-        paths: ['e2e/0.2.0/**/*.feature'],
-        require: ['e2e/0.2.0/support/*.js'],
-        publishQuiet: true
-    }
-}

package/dist/core/DTPlayer.d.ts

@@ -1,8 +0,0 @@
-import DYOToolsComponentWithMeta from './DTComponentWithMeta';
-import { DTAcceptedMetaData, DTPlayerToObject } from '../types';
-export default class DYOToolsPlayer<IComponentMeta extends DTAcceptedMetaData> extends DYOToolsComponentWithMeta<IComponentMeta> {
-    protected _componentType: string;
-    copy(): DYOToolsPlayer<IComponentMeta>;
-    toObject(): DTPlayerToObject<IComponentMeta>;
-    toString(): string;
-}

package/dist/core/DTPlayer.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const DTComponentWithMeta_1 = require("./DTComponentWithMeta");
-class DYOToolsPlayer extends DTComponentWithMeta_1.default {
-    constructor() {
-        super(...arguments);
-        this._componentType = 'player';
-    }
-    copy() {
-        const copyElement = new DYOToolsPlayer(this._key, this._options);
-        copyElement.setManyMeta(Object.assign({}, this.getManyMeta()));
-        return copyElement;
-    }
-    toObject() {
-        const objectPlayer = {
-            id: this._id,
-            key: this._key,
-            type: this._componentType,
-        };
-        if (this._meta && Object.keys(this._meta).length > 0) {
-            objectPlayer.meta = Object.assign({}, this.getManyMeta());
-        }
-        return objectPlayer;
-    }
-    toString() {
-        return `Component ${this._key} - Type: Player`;
-    }
-}
-exports.default = DYOToolsPlayer;
-//# sourceMappingURL=DTPlayer.js.map

package/dist/core/DTPlayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DTPlayer.js","sourceRoot":"","sources":["../../src/core/DTPlayer.ts"],"names":[],"mappings":";;AAAA,+DAA8D;AAG9D,MAAqB,cAA0D,SAAQ,6BAAyC;IAAhI;;QAIY,mBAAc,GAAG,QAAQ,CAAC;IAiDtC,CAAC;IAxCC,IAAI;QACF,MAAM,WAAW,GAAG,IAAI,cAAc,CAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACjF,WAAW,CAAC,WAAW,mBAAM,IAAI,CAAC,WAAW,EAAE,EAAG,CAAC;QAEnD,OAAO,WAAW,CAAC;IACrB,CAAC;IAaD,QAAQ;QACN,MAAM,YAAY,GAAqC;YACrD,EAAE,EAAE,IAAI,CAAC,GAAG;YACZ,GAAG,EAAE,IAAI,CAAC,IAAI;YACd,IAAI,EAAE,IAAI,CAAC,cAAc;SAC1B,CAAC;QAEF,IAAI,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YACpD,YAAY,CAAC,IAAI,qBAAQ,IAAI,CAAC,WAAW,EAAE,CAAE,CAAC;SAC/C;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAOD,QAAQ;QACN,OAAO,aAAa,IAAI,CAAC,IAAI,iBAAiB,CAAC;IACjD,CAAC;CACF;AArDD,iCAqDC"}

package/e2e/0.2.0/epic1.feature

@@ -1,29 +0,0 @@
-Feature: Epic 1 - Manager and bunches
-
-  Scenario: Store of bunches
-    Given my empty manager
-    When I add 5 physical bunches and 2 virtual bunches
-    Then I should have 7 bunches in my manager
-
-  Scenario: No duplicated bunches
-    Given my dominion manager
-    When I add an already existing bunch
-    Then I should see an error "id_conflict"
-
-  Scenario: Easy finding of bunch
-    Given my dominion manager
-    Then I should find my current hand
-    And I should find 2 bunches with
-      | key | hand |
-    And I should find 5 bunches with
-      | owner | PRIAM |
-    And I should find 2 bunches with
-      | cost | 4 |
-
-  Scenario: Bunch removal
-    Given my dominion manager
-    When I remove my current hand
-    Then I shouldn't find my current hand
-    And I should find 1 bunches with
-      | key | hand |
-