stand_socotra_policy_transformer 1.0.0

package/__tests__/retool_utils/socotra_payload.test.js

@@ -0,0 +1,168 @@
+const {load_payload} = require("../__utils__/load_payload");
+const {new_policy_payload, policy_holder_payload, quote_to_retool_payload, retool_to_quote_updated } = require("../../src/retool_utils/socotra_payloads");
+
+describe("Policy Holder Payload", () => {
+    test('fails with descriptive error if just one field is missing', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool.json')
+        delete retool_payload['owner_first_name']
+
+        let res = policy_holder_payload(retool_payload);
+        expect(res.payload).toEqual({});
+        expect(res.error_message).toBe("must include the following fields [owner_first_name]")
+        expect(res.status).toBe("error")
+    });
+    test('fails with descriptive error if just more than one required field is missing', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool.json')
+        delete retool_payload['owner_first_name']
+        delete retool_payload['owner_last_name']
+        delete retool_payload['owner_email']
+        delete retool_payload['owner_phone_number']
+
+        let res = policy_holder_payload(retool_payload);
+        expect(res.payload).toEqual({});
+        expect(res.error_message).toBe("must include the following fields [owner_first_name,owner_last_name,owner_email]")
+        expect(res.status).toBe("error")
+    });
+
+    test('succeeds if all required fields are there', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool.json')
+        let res = policy_holder_payload(retool_payload);
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/sample_new_policy_holder.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    });
+});
+
+describe("New Policy Payload", () => {
+    test("Happy Path works", () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool.json')
+        let res = new_policy_payload(retool_payload, '9bdadf0c-5ce0-4ea7-8f9d-7e7d235522d0');
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/sample_new_quote.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+    test("Works when number set to empty string", () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool.json')
+        retool_payload['home_heating_update_year'] = ""
+        let res = new_policy_payload(retool_payload, '9bdadf0c-5ce0-4ea7-8f9d-7e7d235522d0');
+
+        let expected_payload = load_payload('__tests__/__utils__/payloads/sample_new_quote.json')
+        delete expected_payload['fieldValues']['home_heater_last_updated']
+        expect(res.payload).toEqual(expected_payload);
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+    test("Works with payment schedule override", () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool.json')
+        retool_payload['payment_schedule'] = 'quarterly'
+        let res = new_policy_payload(retool_payload, '9bdadf0c-5ce0-4ea7-8f9d-7e7d235522d0');
+
+        let socotra_quote_payload = load_payload('__tests__/__utils__/payloads/sample_new_quote.json')
+        socotra_quote_payload['paymentScheduleName'] = 'quarterly'
+
+        expect(res.payload).toEqual(socotra_quote_payload);
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+    test("Works with minimal payload with no unneeded fields", () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_minimal_retool.json')
+        let res = new_policy_payload(retool_payload, 'f0d09c62-3ec1-4830-b4b3-17e7bed46560');
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/sample_minimal_socotra_payload.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+})
+
+describe("Retool Payload", () => {
+    test('Happy path converts to retool payload', () => {
+        let socotra_payload = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+        let res = quote_to_retool_payload(socotra_payload)
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/sample_retool_socotra_subset.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+})
+
+describe("Update Socotra Quote", () => {
+    test('Happy path converts to retool payload', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool_socotra_subset.json')
+        retool_payload["protection_class"] = "3"
+        retool_payload["deadbolt"] = "No"
+        retool_payload["coverage_b"] = 300000
+        retool_payload["zip"] = "94655"
+        retool_payload["payment_schedule"] = "upfront"
+
+        let old_quote = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+        delete old_quote['name']
+
+
+        let res = retool_to_quote_updated(retool_payload, old_quote)
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/sample_update_quote.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+    test('Minimal Change Example', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/minimal_change_retool.json')
+        let old_quote = load_payload('__tests__/__utils__/payloads/minimal_change_base.json')
+        delete old_quote['name']
+
+
+        let res = retool_to_quote_updated(retool_payload, old_quote)
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/minimal_change_resulting_socotra.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+    test('Minimal Change Example 2 Nulls from socotra', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/minimal_change_retool2.json')
+        let old_quote = load_payload('__tests__/__utils__/payloads/minimal_change_base2.json')
+        delete old_quote['name']
+
+
+        let res = retool_to_quote_updated(retool_payload, old_quote)
+
+        expect(res.payload).toEqual(load_payload('__tests__/__utils__/payloads/minimal_change_resulting_socotra2.json'));
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+     test('deletes exposure if not needed', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool_socotra_subset.json')
+        retool_payload["coverage_b"] = 300000
+
+        let old_quote = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+
+
+        let res = retool_to_quote_updated(retool_payload, old_quote)
+
+
+        expect(res.payload).not.toHaveProperty("updateExposures")
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+
+    test('deletes field_values if not needed', () => {
+        let retool_payload = load_payload('__tests__/__utils__/payloads/sample_retool_socotra_subset.json')
+        retool_payload["deadbolt"] = "Yes"
+
+        let old_quote = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+
+
+        let res = retool_to_quote_updated(retool_payload, old_quote)
+
+
+        expect(res.payload).not.toHaveProperty("fieldValues")
+        expect(res.error_message).toBe("")
+        expect(res.status).toBe("success")
+    })
+})

package/__tests__/retool_utils/socotra_structure_helper.test.js

@@ -0,0 +1,129 @@
+const {SocotraEntry } = require("../../src/retool_utils/socotra_structure_helper");
+const {load_payload} = require("../__utils__/load_payload");
+describe("SocotraEntry", () => {
+    test('fails with descriptive error if you pick a location that is not supported', () => {
+       expect(() => new SocotraEntry("some id", "quote locator", "bad.location"))
+        .toThrow('Unsupported Socotra Location: bad.location');
+    });
+
+    test('happy path works', () => {
+        let se = new SocotraEntry("some id", "field_name", "policy.fields")
+        expect(se.retool_id).toEqual("some id")
+        expect(se.socotra_id).toEqual("field_name")
+        expect(se.socotra_location).toEqual("policy.fields")
+        expect(se.to_retool_func(5)).toEqual(5)
+        expect(se.to_scotra_func(5)).toEqual(5)
+    });
+});
+
+describe("socotra_create_policy_template", () => {
+    test('gives back a payload with the required attributes empty', () => {
+        let template = SocotraEntry.socotra_create_policy_template('some policy_holder_locator')
+        expect(template.policyholderLocator).toEqual("some policy_holder_locator")
+        expect(template.fieldValues).toEqual({})
+        expect(template.fieldGroups).toEqual([])
+        expect(template.exposures[0].exposureName).toEqual("dwelling")
+        expect(template.exposures[0].fieldGroups).toEqual([])
+        expect(template.exposures[0].fieldValues).toEqual({})
+    })
+})
+
+describe("socotra_create_response", () => {
+    test('works for policy values', () => {
+        let template = SocotraEntry.socotra_create_policy_template("locator")
+        let retool_payload = {"some_id": 42}
+        let se = new SocotraEntry("some_id", "example_field", "policy.fields")
+
+        se.socotra_create_response(retool_payload, template)
+        expect(template.fieldValues.example_field).toEqual(retool_payload["some_id"])
+    });
+
+    test('works for exposure_values', () => {
+        let template = SocotraEntry.socotra_create_policy_template("locator")
+        let retool_payload = {"some_id": 42}
+        let se = new SocotraEntry("some_id", "example_field", "exposure.dwelling.fields")
+
+        se.socotra_create_response(retool_payload, template)
+        expect(template.exposures[0].fieldValues.example_field).toEqual(retool_payload["some_id"])
+    });
+
+    test('works for the effective_date', () => {
+        let template = SocotraEntry.socotra_create_policy_template("locator")
+        let retool_payload = {"start_date": "2024-01-01"}
+        let se = new SocotraEntry("start_date", "startTimestamp", "effective_date")
+
+        se.socotra_create_response(retool_payload, template)
+        expect(template.policyStartTimestamp).toEqual(1704096000000)
+        expect(template.policyEndTimestamp).toEqual(1735718400000)
+    });
+
+    test('applies transformation if one is given', () => {
+        let template = SocotraEntry.socotra_create_policy_template("locator")
+        let retool_payload = {"some_id": 42}
+        let se = new SocotraEntry("some_id", "example_field", "exposure.dwelling.fields", undefined,(x) => x+1)
+
+        se.socotra_create_response(retool_payload, template)
+        expect(template.exposures[0].fieldValues.example_field).toEqual(retool_payload["some_id"] + 1)
+    });
+});
+describe("socotra_create_quote from other quote", () => {
+    test('adds selected values to the right place', () => {
+        let template = SocotraEntry.socotra_create_update_template("exposure_locator")
+        let retool_payload = {"some_policy_id": 42, "some_exposure_field": 43}
+        let se = new SocotraEntry("some_policy_id", "example_field", "policy.fields")
+        let se1 = new SocotraEntry("some_exposure_field", "example_field1", "exposure.dwelling.fields")
+
+        se.socotra_update(retool_payload, template)
+        se1.socotra_update(retool_payload, template)
+        expect(template.fieldValues.example_field).toEqual(retool_payload["some_policy_id"])
+        expect(template.updateExposures[0].fieldValues.example_field1).toEqual(retool_payload["some_exposure_field"])
+    });
+
+    test('works for effective_date', () => {
+        let template = SocotraEntry.socotra_create_update_template("exposure_locator")
+        let retool_payload = {"some_policy_id": 42, "some_exposure_field": 43, "start_date": "2024-01-01"}
+        let se = new SocotraEntry("start_date", "startTimestamp", "effective_date")
+
+        se.socotra_update(retool_payload, template)
+        expect(template.policyStartTimestamp).toEqual(1704096000000)
+        expect(template.policyEndTimestamp).toEqual(1735718400000)
+    });
+});
+
+describe("retool_response", () => {
+    test('works for policy values', () => {
+        let template = {}
+        let socotra_payload = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+        let se = new SocotraEntry("some_id", "gre_wf_score", "policy.fields")
+
+        se.retool_response(socotra_payload, template)
+        expect(template.some_id).toEqual("2.38")
+    });
+
+    test('works for exposure_values', () => {
+        let template = {}
+        let socotra_payload = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+        let se = new SocotraEntry("some_id", "protection_class", "exposure.dwelling.fields")
+
+        se.retool_response(socotra_payload, template)
+        expect(template.some_id).toEqual("2")
+    });
+    test('works for effective_date', () => {
+        let template = {}
+        let socotra_payload = load_payload('__tests__/__utils__/payloads/sample_socotra_quote.json')
+        let se = new SocotraEntry("start_date", "startTimestamp", "effective_date")
+
+        se.retool_response(socotra_payload, template)
+        expect(template.start_date).toEqual("2024-09-06")
+    });
+
+    // test('applies transformation if one is given', () => {
+    //     let template = SocotraEntry.socotra_create_policy_template("locator")
+    //     let retool_payload = {"some_id": 42}
+    //     let se = new SocotraEntry("some_id", "example_field", "exposure.dwelling.fields", (x) => x+1)
+    //
+    //     se.retool_response(retool_payload, template)
+    //     expect(template.exposures[0].fieldValues.example_field).toEqual(retool_payload["some_id"] + 1)
+    // });
+});
+

package/__tests__/underwriter.test.js

@@ -0,0 +1,169 @@
+const {underwrite} = require('../src')
+const {claims_history_helper} = require("./helpers")
+
+beforeAll(() => {
+  jest
+    .useFakeTimers()
+    .setSystemTime(new Date('2024-07-04').getTime());
+});
+
+afterAll(() => {
+  jest.useRealTimers();
+});
+
+describe('Underwriter', () => {
+    describe('with_full_check', () =>{
+        test('Accepts with passing payload', () => {
+            let decision = underwrite(payload_helper())
+            expect(decision.decision).toBe('accept')
+            expect(decision.notes).toEqual([])
+            expect(decision.refers).toEqual([])
+
+            expect(Object.keys(decision.all_decisions).length).toEqual(43)
+            expect(decision.all_decisions['full_replacement_value']).toBe('accept')
+
+            expect(Object.keys(decision.notes_dict).length).toEqual(43)
+            expect(decision.notes_dict['full_replacement_value']).toBe(null)
+        });
+
+       test('Rejects if something in payload rejects', () => {
+           let decision = underwrite(payload_helper({flood_score: 10, is_vacant: "Yes"}))
+           expect(decision.decision).toBe('reject')
+           expect(decision.notes.length).toEqual(2)
+           expect(decision.refers).toEqual([])
+
+           expect(Object.keys(decision.all_decisions).length).toEqual(43)
+           expect(decision.all_decisions['flood_score']).toBe('reject')
+           expect(decision.all_decisions['is_vacant']).toBe('reject')
+
+           expect(Object.keys(decision.notes_dict).length).toEqual(43)
+           expect(decision.notes_dict['flood_score']).not.toBe(null)
+           expect(decision.all_decisions['is_vacant']).not.toBe(null)
+
+       });
+
+       test('Refer if something in payload refers', () => {
+           let decision = underwrite(payload_helper({"full_replacement_value": 6_500_000}))
+           expect(decision.decision).toBe('refer')
+           expect(decision.notes.length).toEqual(0)
+           expect(decision.refers).toEqual(["full_replacement_value"])
+
+           expect(Object.keys(decision.all_decisions).length).toEqual(43)
+           expect(decision.all_decisions['full_replacement_value']).toBe('refer')
+
+           expect(Object.keys(decision.notes_dict).length).toEqual(43)
+       });
+
+       test('Reject if something in payload refers and something else rejects', () => {
+           let decision = underwrite(payload_helper({full_replacement_value: 6_500_000, flood_score: 10}))
+           expect(decision.decision).toBe('reject')
+           expect(decision.notes.length).toEqual(1)
+           expect(decision.refers).toEqual(["full_replacement_value"])
+
+           expect(Object.keys(decision.all_decisions).length).toEqual(43)
+           expect(decision.all_decisions['full_replacement_value']).toBe('refer')
+           expect(decision.all_decisions['flood_score']).toBe('reject')
+
+           expect(Object.keys(decision.notes_dict).length).toEqual(43)
+           expect(decision.notes_dict['full_replacement_value']).toBeNull()
+           expect(decision.notes_dict['flood_score']).not.toBeNull()
+
+       });
+
+       test('Reject if something in payload is missing', () => {
+           payload = payload_helper()
+           delete payload.full_replacement_value
+           delete payload.arf
+           let decision = underwrite(payload)
+           expect(decision.decision).toBe('reject')
+           expect(decision.notes.length).toEqual(2)
+           expect(decision.refers).toEqual([])
+
+           expect(Object.keys(decision.all_decisions).length).toEqual(43)
+           expect(decision.all_decisions['full_replacement_value']).toBe('reject')
+           expect(decision.all_decisions['wf_score_mean']).toBe('reject')
+       });
+    });
+    describe("partial_check", () => {
+        test("doesn't reject for missing fields", ()=> {
+            let decision = underwrite({
+                multi_family_unit_count: 1, primary_dwelling_insured: 'Yes',
+                full_replacement_value: 6_000_000, prior_carrier: "Yes"}, false)
+            expect(decision.decision).toBe('accept')
+            expect(decision.notes).toEqual([])
+            expect(decision.refers).toEqual([])
+
+            expect(Object.keys(decision.all_decisions).length).toEqual(4)
+            expect(decision.all_decisions['full_replacement_value']).toBe('accept')
+        })
+
+        test("rejects if it should", ()=> {
+            let decision = underwrite({
+                multi_family_unit_count: 1, primary_dwelling_insured: 'Yes',
+                full_replacement_value: 6_000_000, prior_carrier: "Yes",
+                number_of_bankruptcies_judgements_or_liens: 2}, false)
+            expect(decision.decision).toBe('reject')
+            expect(decision.notes).toEqual(["Has bankruptcies, judgements, or liens"])
+            expect(decision.refers).toEqual([])
+
+            expect(Object.keys(decision.all_decisions).length).toEqual(5)
+            expect(decision.all_decisions['full_replacement_value']).toBe('accept')
+        });
+    });
+});
+
+function payload_helper(override){
+    let sample_payload = {
+        address: '1234 main street',
+        year_built: '2005',
+        co_applicant_address: '1234 main street',
+        multi_family_unit_count: 1,
+        primary_dwelling_insured: 'Yes',
+        full_replacement_value: 6_000_000,
+        prior_carrier: "Yes",
+        wf_variance: .001,
+        wf_score_mean: .3,
+        arf: 1.9,
+        flood_score: 5,
+        distance_to_coast: 1.4,
+        pool_features: ['Inground', "Fenced with self-locking gate"],
+        number_of_dogs: 1,
+        dog_history: 'No',
+        dog_breeds: ['non-guard dog of other breeds'],
+        exotic_pets: "No",
+        farming_type: "None",
+        number_of_mortgages: 0,
+        number_of_bankruptcies_judgements_or_liens: 0,
+        is_vacant: "No",
+        under_renovation: "No",
+        plumbing_last_update_year: 2022,
+        water_heater_last_update_year: 2022,
+        electrical_last_update_year: 2022,
+        home_heating_last_update_year: 2022,
+        heating_source: 'central gas heat',
+        has_underground_fuel_tank: "No",
+        has_steel_braided_hose: "Yes",
+        has_water_shutoff: "Yes",
+        circuit_breaker: "No",
+        home_business_type: "no",
+        has_attractive_nuisance: "No",
+        home_rental_type: "no",
+        degree_of_slope: 15,
+        construction_type: "Concrete",
+        siding_material: "Adobe",
+        protection_class: "4",
+        roof_material: "Corrugated Steel - Metal",
+        class_a_roof: "Yes",
+        foundation_type: "Crawlspace",
+        has_slab_foundation_plumbing: "No",
+        fire_protective_devices: ["Central"],
+        theft_protective_devices: ["Dead Bolt", "Direct"],
+        occupation: "writer",
+        claims: [
+          claims_history_helper('06/23/2022', 'Hurricane', 100),
+          claims_history_helper('11/1/2020', 'SlipFall', 100)
+        ]
+    }
+
+    return {...sample_payload, ...override}
+}

package/__tests__/wf_knockout.test.js

@@ -0,0 +1,124 @@
+const { knockout } = require('../src/knockouts/index.js');
+const { stand_wf_knockout } = require('../src/knockouts/wf_knockouts')
+describe("WF Knockouts", () =>
+{
+  describe("wf_score_mean", () => {
+
+    test('rejects if mean > 0.7', () => {
+      let result = stand_wf_knockout(.7, .2);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("D");
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("Stand WF mean must be less than or equal to 0.7");
+    });
+
+    test('set as c and refer if arf >= 8', () => {
+      let result = stand_wf_knockout(.1, 8.0);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("C");
+      expect(decision.decision).toBe("refer");
+      expect(decision.note).toBe(null);
+    });
+
+    test('set as c and acept if  5 < arf < 8', () => {
+      let result = stand_wf_knockout(.1, 5.0);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("C");
+      expect(decision.decision).toBe("accept");
+      expect(decision.note).toBe(null);
+    });
+
+    test('set as c and accept if arf <8 and .2 < mean < .7', () => {
+      let result = stand_wf_knockout(.34, 4.2);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("C");
+      expect(decision.decision).toBe("accept");
+      expect(decision.note).toBe(null);
+    });
+
+    test('set as B and accept if arf <5 and .1 < mean < .2', () => {
+      let result = stand_wf_knockout(.14, 4.3);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("B");
+      expect(decision.decision).toBe("accept");
+      expect(decision.note).toBe(null);
+    });
+
+    test('set as A and accept if arf <5 and 0 < mean < .1', () => {
+      let result = stand_wf_knockout(.04, 4.3);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("A");
+      expect(decision.decision).toBe("accept");
+      expect(decision.note).toBe(null);
+    });
+
+    test('negative mean used reject', () => {
+      let result = stand_wf_knockout(-.04, 4.3);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("");
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("Mean and ARF must be positive numbers");
+    });
+
+    test('negative arf used reject', () => {
+      let result = stand_wf_knockout(.04, -4.3);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("");
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("Mean and ARF must be positive numbers");
+    });
+
+    test('non number arf used reject', () => {
+      let result = stand_wf_knockout(.04, "hi");
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("");
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("ARF must be a number");
+    });
+    test('non number arf used reject', () => {
+      let result = stand_wf_knockout("hi", 4);
+      let decision = result.underwriter_result;
+
+      expect(result.category).toBe("");
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("ARF must be a number");
+    });
+
+  });
+
+  describe("WF Variance Knockout", () => {
+
+    test('accept if variance <= 0.09', () => {
+      let decision = knockout('wf_variance', 0.08);
+      expect(decision.decision).toBe("accept");
+      expect(decision.note).toBe(null)
+    });
+
+    test('refer if variance > .09', () => {
+      let decision = knockout('wf_variance', 0.1);
+      expect(decision.decision).toBe("refer");
+      expect(decision.note).toBe(null)
+    });
+
+    test('rejects if value is not an number', () => {
+      let decision = knockout('wf_variance', "hi");
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("Variance must be a number.")
+    });
+
+    test('rejects if value is negative', () => {
+      let decision = knockout('wf_variance', -3);
+      expect(decision.decision).toBe("reject");
+      expect(decision.note).toBe("Variance must be a positive number.")
+    });
+  });
+})

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "stand_socotra_policy_transformer",
+  "version": "1.0.0",
+  "description": "Stands internal javscipt module for executing underwritting",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+    "build": "webpack"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "webpack": "^5.92.1",
+    "webpack-cli": "^5.1.4"
+  }
+}

package/src/index.js

@@ -0,0 +1,3 @@
+const {underwrite, knockout_names} = require('./underwriter')
+const {policy_holder_payload, new_policy_payload, quote_to_retool_payload, retool_to_quote_updated} = require('./retool_utils/socotra_payloads')
+module.exports = {underwrite, knockout_names, policy_holder_payload, new_policy_payload, quote_to_retool_payload, retool_to_quote_updated}

package/src/knockouts/basic_knockouts.js

@@ -0,0 +1,66 @@
+function multi_family_unit_count(num_units){
+
+    if(!Number.isInteger(num_units)){
+        return {decision: "reject", note: "Number of units must be an integer"}
+    }
+    else if(num_units > 2){
+        return {decision: "reject", note: "We only allow homes with two units or less."}
+    } else if (num_units <= 0){
+        return {decision: "reject", note: "Number of units must be greater than 0"}
+    }
+    else{
+        return {decision: "accept", note: null}
+    }
+}
+
+function primary_dwelling_is_insured(is_insured_string){
+
+    if(is_insured_string == 'No'){
+        return {decision: "refer", note: null}
+    } else if(is_insured_string == 'Yes'){
+        return {decision: "accept", note: null}
+    } else {
+        return {decision: "reject", note: "Primary dwelling insured value must be in ['yes', 'no']"}
+    }
+}
+
+function full_replacement_value(replacement_value){
+    if(!Number.isInteger(replacement_value)){
+        return {decision: "reject", note: "Full replacement value must be an integer"}
+    }
+    else if(replacement_value > 6_000_000){
+        return {decision: "refer", note: null}
+    } else if (replacement_value < 2_000_000){
+        return {decision: "reject", note: "We only insure homes greater than $1M"}
+    }
+    else{
+        return {decision: "accept", note: null}
+    }
+}
+
+function prior_carrier(carrier_string){
+
+    if(carrier_string === ""){
+        return {decision: "refer", note: null}
+    } else if(typeof carrier_string == 'string'){
+        return {decision: "accept", note: null}
+    } else {
+         return {decision: "reject", note: "Prior Carrier Must be a string"}
+    }
+}
+
+function occupation(occ){
+    if(typeof occ != 'string'){
+        return {decision: "reject", note: "Occupation must be a string"}
+    } else if (['Professional Athlete', 'Entertainer', 'Journalist',' Politician'].includes(occ)){
+        return {decision: "refer", note: null}
+    } else {
+        return {decision: "accept", note: null}
+    }
+}
+
+
+module.exports = {
+    multi_family_unit_count, primary_dwelling_is_insured, full_replacement_value, prior_carrier,
+    occupation
+}