unleash-server 4.1.2 → 4.2.0-1

package/dist/test/e2e/api/admin/project/feature.strategy.e2e.test.js

@@ -6,16 +6,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const database_init_1 = __importDefault(require("../../../helpers/database-init"));
 const test_helper_1 = require("../../../helpers/test-helper");
 const no_logger_1 = __importDefault(require("../../../../fixtures/no-logger"));
+const constants_1 = require("../../../../../lib/util/constants");
+const events_1 = require("../../../../../lib/types/events");
 let app;
 let db;
+const sortOrderFirst = 0;
+const sortOrderSecond = 10;
+const sortOrderDefault = 9999;
 beforeAll(async () => {
-    db = await database_init_1.default('feature_strategy_api_serial', no_logger_1.default);
-    app = await test_helper_1.setupApp(db.stores);
+    db = await (0, database_init_1.default)('feature_strategy_api_serial', no_logger_1.default);
+    app = await (0, test_helper_1.setupApp)(db.stores);
+});
+afterEach(async () => {
+    const all = await db.stores.projectStore.getEnvironmentsForProject('default');
+    await Promise.all(all
+        .filter((env) => env !== constants_1.DEFAULT_ENV)
+        .map(async (env) => db.stores.projectStore.deleteEnvironmentForProject('default', env)));
 });
 afterAll(async () => {
     await app.destroy();
     await db.destroy();
 });
+async function addStrategies(featureName, envName) {
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+    })
+        .expect(200);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+        sortOrder: sortOrderFirst,
+    })
+        .expect(200);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+        sortOrder: sortOrderSecond,
+    })
+        .expect(200);
+}
 test('Trying to add a strategy configuration to environment not connected to toggle should fail', async () => {
     await app.request
         .post('/api/admin/features')
@@ -100,11 +142,10 @@ test('Project overview includes environment connected to feature', async () => {
         expect(res.body.name).toBe('com.test.environment');
         expect(res.body.createdAt).toBeTruthy();
     });
-    await app.request
-        .post('/api/admin/environments')
-        .send({ name: 'project-overview', displayName: 'Project Overview' })
-        .set('Content-Type', 'application/json')
-        .expect(201);
+    await db.stores.environmentStore.create({
+        name: 'project-overview',
+        type: 'production',
+    });
     await app.request
         .post('/api/admin/projects/default/environments')
         .send({ environment: 'project-overview' })
@@ -113,7 +154,7 @@ test('Project overview includes environment connected to feature', async () => {
         .get('/api/admin/projects/default')
         .expect(200)
         .expect((r) => {
-        expect(r.body.features[0].environments[0].name).toBe(':global:');
+        expect(r.body.features[0].environments[0].name).toBe(constants_1.DEFAULT_ENV);
         expect(r.body.features[0].environments[1].name).toBe('project-overview');
     });
 });
@@ -131,11 +172,10 @@ test('Disconnecting environment from project, removes environment from features
         expect(res.body.name).toBe('com.test.disconnect.environment');
         expect(res.body.createdAt).toBeTruthy();
     });
-    await app.request
-        .post('/api/admin/environments')
-        .send({ name: 'dis-project-overview', displayName: 'Project Overview' })
-        .set('Content-Type', 'application/json')
-        .expect(201);
+    await db.stores.environmentStore.create({
+        name: 'dis-project-overview',
+        type: 'production',
+    });
     await app.request
         .post('/api/admin/projects/default/environments')
         .send({ environment: 'dis-project-overview' })
@@ -150,17 +190,14 @@ test('Disconnecting environment from project, removes environment from features
         expect(r.body.features.some((e) => e.environment === 'dis-project-overview')).toBeFalsy();
     });
 });
-test('Can enable/disable environment for feature', async () => {
+test('Can enable/disable environment for feature with strategies', async () => {
     const envName = 'enable-feature-environment';
+    const featureName = 'com.test.enable.environment';
     // Create environment
-    await app.request
-        .post('/api/admin/environments')
-        .send({
+    await db.stores.environmentStore.create({
         name: envName,
-        displayName: 'Enable feature for environment',
-    })
-        .set('Content-Type', 'application/json')
-        .expect(201);
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -172,21 +209,30 @@ test('Can enable/disable environment for feature', async () => {
     await app.request
         .post('/api/admin/projects/default/features')
         .send({
-        name: 'com.test.enable.environment',
-        strategies: [{ name: 'default' }],
+        name: featureName,
     })
         .set('Content-Type', 'application/json')
         .expect(201)
         .expect((res) => {
-        expect(res.body.name).toBe('com.test.enable.environment');
+        expect(res.body.name).toBe(featureName);
         expect(res.body.createdAt).toBeTruthy();
     });
+    // Add strategy to it
     await app.request
-        .post('/api/admin/projects/default/features/com.test.enable.environment/environments/enable-feature-environment/on')
-        .send({})
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+    })
         .expect(200);
     await app.request
-        .get('/api/admin/projects/default/features/com.test.enable.environment')
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/on`)
+        .set('Content-Type', 'application/json')
+        .expect(200);
+    await app.request
+        .get(`/api/admin/projects/default/features/${featureName}`)
         .expect(200)
         .expect('Content-Type', /json/)
         .expect((res) => {
@@ -195,11 +241,11 @@ test('Can enable/disable environment for feature', async () => {
         expect(enabledFeatureEnv.enabled).toBe(true);
     });
     await app.request
-        .post('/api/admin/projects/default/features/com.test.enable.environment/environments/enable-feature-environment/off')
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/off`)
         .send({})
         .expect(200);
     await app.request
-        .get('/api/admin/projects/default/features/com.test.enable.environment')
+        .get(`/api/admin/projects/default/features/${featureName}`)
         .expect(200)
         .expect('Content-Type', /json/)
         .expect((res) => {
@@ -230,6 +276,15 @@ test('Can use new project feature toggle endpoint to create feature toggle witho
         expect(res.body.project).toBe('default');
     });
 });
+test('Can create feature toggle without strategies', async () => {
+    const name = 'new.toggle.without.strategy.2';
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({ name });
+    const { body: toggle } = await app.request.get(`/api/admin/projects/default/features/${name}`);
+    expect(toggle.environments).toHaveLength(1);
+    expect(toggle.environments[0].strategies).toHaveLength(0);
+});
 test('Still validates feature toggle input when creating', async () => {
     await app.request
         .post('/api/admin/projects/default/features')
@@ -266,14 +321,10 @@ test('Trying to create toggle under project that does not exist should fail', as
 test('Can get environment info for feature toggle', async () => {
     const envName = 'environment-info';
     // Create environment
-    await app.request
-        .post('/api/admin/environments')
-        .send({
+    await db.stores.environmentStore.create({
         name: envName,
-        displayName: 'Enable feature for environment',
-    })
-        .set('Content-Type', 'application/json')
-        .expect(201);
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -322,17 +373,96 @@ test('Getting feature that does not exist should yield 404', async () => {
         .get('/api/admin/projects/default/features/non.existing.feature')
         .expect(404);
 });
-test('Can add strategy to feature toggle', async () => {
-    const envName = 'add-strategy';
-    // Create environment
+test('Should update feature toggle', async () => {
+    const url = '/api/admin/projects/default/features';
+    const name = 'new.toggle.update';
+    await app.request
+        .post(url)
+        .send({ name, description: 'some', type: 'release' })
+        .expect(201);
+    await app.request
+        .put(`${url}/${name}`)
+        .send({ name, description: 'updated', type: 'kill-switch' })
+        .expect(200);
+    const { body: toggle } = await app.request.get(`${url}/${name}`);
+    expect(toggle.name).toBe(name);
+    expect(toggle.description).toBe('updated');
+    expect(toggle.type).toBe('kill-switch');
+    expect(toggle.archived).toBeFalsy();
+});
+test('Should not change name of feature toggle', async () => {
+    const url = '/api/admin/projects/default/features';
+    const name = 'new.toggle.update.2';
+    await app.request
+        .post(url)
+        .send({ name, description: 'some', type: 'release' })
+        .expect(201);
+    await app.request
+        .put(`${url}/${name}`)
+        .send({ name: 'new name', description: 'updated', type: 'kill-switch' })
+        .expect(400);
+});
+test('Should not change project of feature toggle even if it is part of body', async () => {
+    const url = '/api/admin/projects/default/features';
+    const name = 'new.toggle.update.3';
     await app.request
-        .post('/api/admin/environments')
+        .post(url)
+        .send({ name, description: 'some', type: 'release' })
+        .expect(201);
+    const { body } = await app.request
+        .put(`${url}/${name}`)
         .send({
-        name: envName,
-        displayName: 'Enable feature for environment',
+        name,
+        description: 'updated',
+        type: 'kill-switch',
+        project: 'new',
     })
-        .set('Content-Type', 'application/json')
+        .expect(200);
+    expect(body.project).toBe('default');
+});
+test('Should patch feature toggle', async () => {
+    const url = '/api/admin/projects/default/features';
+    const name = 'new.toggle.patch';
+    await app.request
+        .post(url)
+        .send({ name, description: 'some', type: 'release' })
+        .expect(201);
+    await app.request
+        .patch(`${url}/${name}`)
+        .send([
+        { op: 'replace', path: '/description', value: 'New desc' },
+        { op: 'replace', path: '/type', value: 'kill-switch' },
+    ])
+        .expect(200);
+    const { body: toggle } = await app.request.get(`${url}/${name}`);
+    expect(toggle.name).toBe(name);
+    expect(toggle.description).toBe('New desc');
+    expect(toggle.type).toBe('kill-switch');
+    expect(toggle.archived).toBeFalsy();
+});
+test('Should archive feature toggle', async () => {
+    const url = '/api/admin/projects/default/features';
+    const name = 'new.toggle.archive';
+    await app.request
+        .post(url)
+        .send({ name, description: 'some', type: 'release' })
         .expect(201);
+    await app.request.delete(`${url}/${name}`);
+    await app.request.get(`${url}/${name}`).expect(404);
+    const { body } = await app.request
+        .get(`/api/admin/archive/features`)
+        .expect(200);
+    const toggle = body.features.find((f) => f.name === name);
+    expect(toggle).toBeDefined();
+});
+test('Can add strategy to feature toggle to a "some-env-2"', async () => {
+    const envName = 'some-env-2';
+    const featureName = 'feature.strategy.toggle';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -340,7 +470,6 @@ test('Can add strategy to feature toggle', async () => {
         environment: envName,
     })
         .expect(200);
-    const featureName = 'feature.strategy.toggle';
     await app.request
         .post('/api/admin/projects/default/features')
         .send({ name: featureName })
@@ -357,20 +486,79 @@ test('Can add strategy to feature toggle', async () => {
     await app.request
         .get(`/api/admin/projects/default/features/${featureName}`)
         .expect((res) => {
-        expect(res.body.environments[0].strategies).toHaveLength(1);
+        const env = res.body.environments.find((e) => e.name === envName);
+        expect(env.strategies).toHaveLength(1);
     });
 });
-test('Can get strategies for feature and environment', async () => {
-    const envName = 'get-strategy';
-    // Create environment
+test('Environments are returned in sortOrder', async () => {
+    const sortedSecond = 'sortedSecond';
+    const sortedLast = 'sortedLast';
+    const featureName = 'feature.strategy.toggle.sortOrder';
+    // Create environments
+    await db.stores.environmentStore.create({
+        name: sortedLast,
+        type: 'production',
+        sortOrder: 8000,
+    });
+    await db.stores.environmentStore.create({
+        name: sortedSecond,
+        type: 'production',
+        sortOrder: 8,
+    });
+    // Connect environments to project
     await app.request
-        .post('/api/admin/environments')
+        .post('/api/admin/projects/default/environments')
         .send({
-        name: envName,
-        displayName: 'Enable feature for environment',
+        environment: sortedSecond,
     })
-        .set('Content-Type', 'application/json')
+        .expect(200);
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({
+        environment: sortedLast,
+    })
+        .expect(200);
+    /* Create feature toggle */
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({ name: featureName })
         .expect(201);
+    /* create strategies connected to feature toggle */
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${sortedSecond}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+    })
+        .expect(200);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${sortedLast}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+    })
+        .expect(200);
+    await app.request
+        .get(`/api/admin/projects/default/features/${featureName}`)
+        .expect(200)
+        .expect((res) => {
+        expect(res.body.environments).toHaveLength(3);
+        expect(res.body.environments[0].name).toBe(constants_1.DEFAULT_ENV);
+        expect(res.body.environments[1].name).toBe(sortedSecond);
+        expect(res.body.environments[2].name).toBe(sortedLast);
+    });
+});
+test('Can get strategies for feature and environment', async () => {
+    const envName = 'get-strategy';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -413,14 +601,10 @@ test('Getting strategies for environment that does not exist yields 404', async
 test('Can update a strategy based on id', async () => {
     const envName = 'feature.update.strategies';
     // Create environment
-    await app.request
-        .post('/api/admin/environments')
-        .send({
+    await db.stores.environmentStore.create({
         name: envName,
-        displayName: 'Enable feature for environment',
-    })
-        .set('Content-Type', 'application/json')
-        .expect(201);
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -461,14 +645,10 @@ test('Can update a strategy based on id', async () => {
 test('Trying to update a non existing feature strategy should yield 404', async () => {
     const envName = 'feature.non.existing.strategy';
     // Create environment
-    await app.request
-        .post('/api/admin/environments')
-        .send({
+    await db.stores.environmentStore.create({
         name: envName,
-        displayName: 'Enable feature for environment',
-    })
-        .set('Content-Type', 'application/json')
-        .expect(201);
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -486,17 +666,59 @@ test('Trying to update a non existing feature strategy should yield 404', async
         .send({ parameters: { fancyField: 'string' } })
         .expect(404);
 });
-test('Trying to get a non existing feature strategy should yield 404', async () => {
-    const envName = 'feature.non.existing.strategy.get';
+test('Can patch a strategy based on id', async () => {
+    const BASE_URI = '/api/admin/projects/default';
+    const envName = 'feature.patch.strategies';
+    const featureName = 'feature.patch.strategies';
     // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'test',
+    });
+    // Connect environment to project
     await app.request
-        .post('/api/admin/environments')
+        .post(`${BASE_URI}/environments`)
         .send({
-        name: envName,
-        displayName: 'Enable feature for environment',
+        environment: envName,
     })
-        .set('Content-Type', 'application/json')
+        .expect(200);
+    await app.request
+        .post(`${BASE_URI}/features`)
+        .send({ name: featureName })
         .expect(201);
+    let strategy;
+    await app.request
+        .post(`${BASE_URI}/features/${featureName}/environments/${envName}/strategies`)
+        .send({
+        name: 'flexibleRollout',
+        parameters: {
+            groupId: 'demo',
+            rollout: 20,
+            stickiness: 'default',
+        },
+    })
+        .expect(200)
+        .expect((res) => {
+        strategy = res.body;
+    });
+    await app.request
+        .patch(`${BASE_URI}/features/${featureName}/environments/${envName}/strategies/${strategy.id}`)
+        .send([{ op: 'replace', path: '/parameters/rollout', value: 42 }])
+        .expect(200);
+    await app.request
+        .get(`${BASE_URI}/features/${featureName}/environments/${envName}/strategies/${strategy.id}`)
+        .expect(200)
+        .expect((res) => {
+        expect(res.body.parameters.rollout).toBe(42);
+    });
+});
+test('Trying to get a non existing feature strategy should yield 404', async () => {
+    const envName = 'feature.non.existing.strategy.get';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'production',
+    });
     // Connect environment to project
     await app.request
         .post('/api/admin/projects/default/environments')
@@ -513,4 +735,213 @@ test('Trying to get a non existing feature strategy should yield 404', async ()
         .get(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies/some-non-existing-id`)
         .expect(404);
 });
+test('Can not enable environment for feature without strategies', async () => {
+    const environment = 'some-env';
+    const featureName = 'com.test.enable.environment.disabled';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: environment,
+        type: 'test',
+    });
+    // Connect environment to project
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({ environment })
+        .expect(200);
+    // Create feature
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({
+        name: featureName,
+    })
+        .set('Content-Type', 'application/json')
+        .expect(201);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${environment}/on`)
+        .set('Content-Type', 'application/json')
+        .expect(403);
+    await app.request
+        .get(`/api/admin/projects/default/features/${featureName}`)
+        .expect(200)
+        .expect('Content-Type', /json/)
+        .expect((res) => {
+        const enabledFeatureEnv = res.body.environments.find((e) => e.name === environment);
+        expect(enabledFeatureEnv.enabled).toBe(false);
+        expect(enabledFeatureEnv.type).toBe('test');
+    });
+});
+test('Enabling environment creates a FEATURE_ENVIRONMENT_ENABLED event', async () => {
+    const environment = 'environment_enabled_env';
+    const featureName = 'com.test.enable.environment.event.sent';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: environment,
+        type: 'test',
+    });
+    // Connect environment to project
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({ environment })
+        .expect(200);
+    // Create feature
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({
+        name: featureName,
+    })
+        .set('Content-Type', 'application/json')
+        .expect(201);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${environment}/strategies`)
+        .send({ name: 'default', constraints: [], properties: {} })
+        .expect(200);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${environment}/on`)
+        .set('Content-Type', 'application/json')
+        .expect(200);
+    const events = await db.stores.eventStore.getAll({
+        type: events_1.FEATURE_ENVIRONMENT_ENABLED,
+    });
+    const enabledEvents = events.filter((e) => e.data.name === featureName);
+    expect(enabledEvents).toHaveLength(1);
+});
+test('Disabling environment creates a FEATURE_ENVIRONMENT_DISABLED event', async () => {
+    const environment = 'environment_disabled_env';
+    const featureName = 'com.test.enable.environment_disabled.sent';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: environment,
+        type: 'test',
+    });
+    // Connect environment to project
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({ environment })
+        .expect(200);
+    // Create feature
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({
+        name: featureName,
+    })
+        .set('Content-Type', 'application/json')
+        .expect(201);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${environment}/strategies`)
+        .send({ name: 'default', constraints: [], properties: {} })
+        .expect(200);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${environment}/off`)
+        .set('Content-Type', 'application/json')
+        .expect(200);
+    const events = await db.stores.eventStore.getAll({
+        type: events_1.FEATURE_ENVIRONMENT_DISABLED,
+    });
+    const ourFeatureEvent = events.find((e) => e.data.name === featureName);
+    expect(ourFeatureEvent).toBeTruthy();
+});
+test('Can delete strategy from feature toggle', async () => {
+    const envName = 'del-strategy';
+    const featureName = 'feature.strategy.toggle.delete.strategy';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'test',
+    });
+    // Connect environment to project
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({
+        environment: envName,
+    })
+        .expect(200);
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({ name: featureName })
+        .expect(201);
+    await app.request
+        .post(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`)
+        .send({
+        name: 'default',
+        parameters: {
+            userId: 'string',
+        },
+    })
+        .expect(200);
+    const { body } = await app.request.get(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`);
+    const strategies = body;
+    const strategyId = strategies[0].id;
+    await app.request
+        .delete(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies/${strategyId}`)
+        .expect(200);
+});
+test('List of strategies should respect sortOrder', async () => {
+    const envName = 'sortOrderdel-strategy';
+    const featureName = 'feature.sort.order.one';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'test',
+    });
+    // Connect environment to project
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({
+        environment: envName,
+    })
+        .expect(200);
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({ name: featureName })
+        .expect(201);
+    await addStrategies(featureName, envName);
+    const { body } = await app.request.get(`/api/admin/projects/default/features/${featureName}/environments/${envName}/strategies`);
+    const strategies = body;
+    expect(strategies[0].sortOrder).toBe(sortOrderFirst);
+    expect(strategies[1].sortOrder).toBe(sortOrderSecond);
+    expect(strategies[2].sortOrder).toBe(sortOrderDefault);
+});
+test('Feature strategies list should respect strategy sortorders for each environment', async () => {
+    const envName = 'sort-order-within-environment-one';
+    const secondEnv = 'sort-order-within-environment-two';
+    const featureName = 'feature.sort.order.environment.list';
+    // Create environment
+    await db.stores.environmentStore.create({
+        name: envName,
+        type: 'test',
+    });
+    await db.stores.environmentStore.create({
+        name: secondEnv,
+        type: 'test',
+    });
+    // Connect environment to project
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({
+        environment: envName,
+    })
+        .expect(200);
+    await app.request
+        .post('/api/admin/projects/default/environments')
+        .send({
+        environment: secondEnv,
+    })
+        .expect(200);
+    await app.request
+        .post('/api/admin/projects/default/features')
+        .send({ name: featureName })
+        .expect(201);
+    await addStrategies(featureName, envName);
+    await addStrategies(featureName, secondEnv);
+    const response = await app.request.get(`/api/admin/projects/default/features/${featureName}`);
+    const { body } = response;
+    let { strategies } = body.environments.find((e) => e.name === envName);
+    expect(strategies[0].sortOrder).toBe(sortOrderFirst);
+    expect(strategies[1].sortOrder).toBe(sortOrderSecond);
+    expect(strategies[2].sortOrder).toBe(sortOrderDefault);
+    strategies = body.environments.find((e) => e.name === secondEnv).strategies;
+    expect(strategies[0].sortOrder).toBe(sortOrderFirst);
+    expect(strategies[1].sortOrder).toBe(sortOrderSecond);
+    expect(strategies[2].sortOrder).toBe(sortOrderDefault);
+});
 //# sourceMappingURL=feature.strategy.e2e.test.js.map