[FME-4362] update sdk version and add support for evaluation options

Author: ZamoraEmmanuel

client/__tests__/allTreatments.test.js

@@ -259,4 +259,44 @@ describe('get-all-treatments', () => {
       .set('Authorization', 'test');
     expectOkAllTreatments(response, 200, expected, 2);
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-all-treatments?keys=[{"matchingKey":"test","trafficType":"localhost"}]&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-all-treatments?keys=[{"matchingKey":"test","trafficType":"localhost"}]')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-all-treatments?keys=[{"matchingKey":"test","trafficType":"localhost"}]&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'test');
+    expect(response.status).toBe(200);
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-all-treatments?keys=[{"matchingKey":"test","trafficType":"localhost"}]')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'test');
+    expect(response.status).toBe(200);
+  });
 });

client/__tests__/allTreatmentsWithConfig.test.js

@@ -267,4 +267,44 @@ describe('get-all-treatments-with-config', () => {
       .set('Authorization', 'test');
     expectOkAllTreatments(response, 200, expected, 2);
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-all-treatments-with-config?keys=[{"matchingKey":"test","trafficType":"localhost"}]&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-all-treatments-with-config?keys=[{"matchingKey":"test","trafficType":"localhost"}]')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-all-treatments-with-config?keys=[{"matchingKey":"test","trafficType":"localhost"}]&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'test');
+    expect(response.status).toBe(200);
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-all-treatments-with-config?keys=[{"matchingKey":"test","trafficType":"localhost"}]')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'test');
+    expect(response.status).toBe(200);
+  });
 });

client/__tests__/treatment.test.js

@@ -247,4 +247,44 @@ describe('get-treatment', () => {
       .set('Authorization', 'test');
     expectOk(response, 200, 'control', 'nonexistant-experiment');
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-treatment?key=test&split-name=my-experiment&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-treatment?key=test&split-name=my-experiment')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-treatment?key=test&split-name=my-experiment&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'test');
+    expectOk(response, 200, 'on', 'my-experiment');
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-treatment?key=test&split-name=my-experiment')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'test');
+    expectOk(response, 200, 'on', 'my-experiment');
+  });
 });

client/__tests__/treatmentWithConfig.test.js

@@ -229,4 +229,44 @@ describe('get-treatment-with-config', () => {
       .set('Authorization', 'test');
     expectOk(response, 200, 'control', 'nonexistant-experiment', null);
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-treatment-with-config?key=test&split-name=my-experiment&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-treatment-with-config?key=test&split-name=my-experiment')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-treatment-with-config?key=test&split-name=my-experiment&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'test');
+    expectOk(response, 200, 'on', 'my-experiment', '{"desc" : "this applies only to ON treatment"}');
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-treatment-with-config?key=test&split-name=my-experiment')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'test');
+    expectOk(response, 200, 'on', 'my-experiment', '{"desc" : "this applies only to ON treatment"}');
+  });
 });

client/__tests__/treatments.test.js

@@ -267,4 +267,52 @@ describe('get-treatments', () => {
       },
     }, 3);
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-treatments?key=test&split-names=my-experiment&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-treatments?key=test&split-names=my-experiment')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-treatments?key=test&split-names=my-experiment&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'test');
+    expectOkMultipleResults(response, 200, {
+      'my-experiment': {
+        treatment: 'on',
+      },
+    }, 1);
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-treatments?key=test&split-names=my-experiment')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'test');
+    expectOkMultipleResults(response, 200, {
+      'my-experiment': {
+        treatment: 'on',
+      },
+    }, 1);
+  });
 });

client/__tests__/treatmentsByFlagSets.test.js

@@ -7,7 +7,7 @@ const { expectedGreenResults, expectedPurpleResults, expectedPinkResults } = req
 jest.mock('node-fetch', () => {
   return jest.fn().mockImplementation((url) => {
 
-    const sdkUrl = 'https://sdk.test.io/api/splitChanges?s=1.1&since=-1';
+    const sdkUrl = 'https://sdk.test.io/api/splitChanges?s=1.3&since=-1';
     const splitChange2 = require('../../utils/mocks/splitchanges.since.-1.till.1602796638344.json');
     if (url.startsWith(sdkUrl)) return Promise.resolve({ status: 200, json: () => (splitChange2), ok: true });
 
@@ -273,4 +273,44 @@ describe('get-treatments-by-sets', () => {
       .set('Authorization', 'key_pink');
     expectOkMultipleResults(response, 200, expectedPinkResults, 5);
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-treatments-by-sets?key=test&flag-sets=set_green&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'key_green');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-treatments-by-sets?key=test&flag-sets=set_green')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'key_green');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-treatments-by-sets?key=test&flag-sets=set_green&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'key_green');
+    expect(response.status).toBe(200);
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-treatments-by-sets?key=test&flag-sets=set_green')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'key_green');
+    expect(response.status).toBe(200);
+  });
 });

client/__tests__/treatmentsWithConfig.test.js

@@ -252,4 +252,54 @@ describe('get-treatments-with-config', () => {
       },
     }, 3);
   });
+
+  test('should be 400 if options.properties is invalid (GET)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .get('/client/get-treatments-with-config?key=test&split-names=my-experiment&options={"properties":{"invalid":[1,2,3]}}')
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 400 if options.properties is invalid (POST)', async () => {
+    const expected = [
+      'options.properties must only contain boolean, string, or number values.'
+    ];
+    const response = await request(app)
+      .post('/client/get-treatments-with-config?key=test&split-names=my-experiment')
+      .send({
+        options: { properties: { invalid: [1, 2, 3] } },
+      })
+      .set('Authorization', 'test');
+    expectErrorContaining(response, 400, expected);
+  });
+
+  test('should be 200 if options.properties is valid (GET)', async () => {
+    const response = await request(app)
+      .get('/client/get-treatments-with-config?key=test&split-names=my-experiment&options={"properties":{"package":"premium","admin":true,"discount":50}}')
+      .set('Authorization', 'test');
+    expectOkMultipleResults(response, 200, {
+      'my-experiment': {
+        treatment: 'on',
+        config: '{"desc" : "this applies only to ON treatment"}',
+      },
+    }, 1);
+  });
+
+  test('should be 200 if options.properties is valid (POST)', async () => {
+    const response = await request(app)
+      .post('/client/get-treatments-with-config?key=test&split-names=my-experiment')
+      .send({
+        options: { properties: { package: 'premium', admin: true, discount: 50 } },
+      })
+      .set('Authorization', 'test');
+    expectOkMultipleResults(response, 200, {
+      'my-experiment': {
+        treatment: 'on',
+        config: '{"desc" : "this applies only to ON treatment"}',
+      },
+    }, 1);
+  });
 });

client/__tests__/treatmentsWithConfigByFlagSets.test.js

@@ -6,7 +6,7 @@ const { expectedGreenResultsWithConfig, expectedPurpleResultsWithConfig, expecte
 
 jest.mock('node-fetch', () => {
   return jest.fn().mockImplementation((url) => {
-    const sdkUrl = 'https://sdk.test.io/api/splitChanges?s=1.1&since=-1';
+    const sdkUrl = 'https://sdk.test.io/api/splitChanges?s=1.3&since=-1';
     const splitChange2 = require('../../utils/mocks/splitchanges.since.-1.till.1602796638344.json');
     if (url.startsWith(sdkUrl)) return Promise.resolve({ status: 200, json: () => (splitChange2), ok: true});
     return Promise.resolve({ status: 200, json: () => ({}), ok: true });