def test_create_kits(self):
        with Transaction() as t:
            admin_repo = AdminRepo(t)

            with self.assertRaisesRegex(KeyError, "does not exist"):
                admin_repo.create_kits(5, 3, '', ['foo', 'bar'])

            non_tmi = admin_repo.create_kits(5, 3, '',
                                             ['Project - /J/xL_|Eãt'])
            self.assertEqual([
                'created',
            ], list(non_tmi.keys()))
            self.assertEqual(len(non_tmi['created']), 5)
            for obj in non_tmi['created']:
                self.assertEqual(len(obj['sample_barcodes']), 3)
                self.assertEqual({'kit_id', 'kit_uuid', 'sample_barcodes'},
                                 set(obj))

            # should not be present in the ag tables
            non_tmi_kits = [k['kit_id'] for k in non_tmi['created']]
            with t.cursor() as cur:
                cur.execute(
                    "SELECT supplied_kit_id "
                    "FROM ag.ag_kit "
                    "WHERE supplied_kit_id IN %s", (tuple(non_tmi_kits), ))
                observed = cur.fetchall()
                self.assertEqual(len(observed), 0)

            tmi = admin_repo.create_kits(4, 2, 'foo', ['American Gut Project'])
            self.assertEqual([
                'created',
            ], list(tmi.keys()))
            self.assertEqual(len(tmi['created']), 4)
            for obj in tmi['created']:
                self.assertEqual(len(obj['sample_barcodes']), 2)
                self.assertEqual({'kit_id', 'kit_uuid', 'sample_barcodes'},
                                 set(obj))
                self.assertTrue(obj['kit_id'].startswith('foo_'))

            # should be present in the ag tables
            tmi_kits = [k['kit_id'] for k in tmi['created']]
            with t.cursor() as cur:
                cur.execute(
                    "SELECT supplied_kit_id "
                    "FROM ag.ag_kit "
                    "WHERE supplied_kit_id IN %s", (tuple(tmi_kits), ))
                observed = cur.fetchall()
                self.assertEqual(len(observed), 4)
def create_kits(body, token_info):
    validate_admin_access(token_info)

    number_of_kits = body['number_of_kits']
    number_of_samples = body['number_of_samples']
    kit_prefix = body.get('kit_id_prefix', None)
    projects = body['projects']

    with Transaction() as t:
        admin_repo = AdminRepo(t)

        try:
            kits = admin_repo.create_kits(number_of_kits, number_of_samples,
                                          kit_prefix, projects)
        except KeyError:
            return jsonify(code=422, message="Unable to create kits"), 422
        else:
            t.commit()

    return jsonify(kits), 201
Esempio n. 3
0
    def test_create_kits_success_not_microsetta(self):
        with Transaction() as t:
            admin_repo = AdminRepo(t)
            non_tmi = admin_repo.create_kits(5, 3, '',
                                             [33])
            self.assertEqual(['created', ], list(non_tmi.keys()))
            self.assertEqual(len(non_tmi['created']), 5)
            for obj in non_tmi['created']:
                self.assertEqual(len(obj['sample_barcodes']), 3)
                self.assertEqual({'kit_id', 'kit_uuid', 'sample_barcodes'},
                                 set(obj))

            # should not be present in the ag tables
            non_tmi_kits = [k['kit_id'] for k in non_tmi['created']]
            with t.cursor() as cur:
                cur.execute("SELECT supplied_kit_id "
                            "FROM ag.ag_kit "
                            "WHERE supplied_kit_id IN %s",
                            (tuple(non_tmi_kits),))
                observed = cur.fetchall()
                self.assertEqual(len(observed), 0)
Esempio n. 4
0
    def test_create_kits_success_is_microsetta(self):
        with Transaction() as t:
            admin_repo = AdminRepo(t)
            tmi = admin_repo.create_kits(4, 2, 'foo',
                                         [1])
            self.assertEqual(['created', ], list(tmi.keys()))
            self.assertEqual(len(tmi['created']), 4)
            for obj in tmi['created']:
                self.assertEqual(len(obj['sample_barcodes']), 2)
                self.assertEqual({'kit_id', 'kit_uuid', 'sample_barcodes'},
                                 set(obj))
                self.assertTrue(obj['kit_id'].startswith('foo_'))

            # should be present in the ag tables
            tmi_kits = [k['kit_id'] for k in tmi['created']]
            with t.cursor() as cur:
                cur.execute("SELECT supplied_kit_id "
                            "FROM ag.ag_kit "
                            "WHERE supplied_kit_id IN %s",
                            (tuple(tmi_kits),))
                observed = cur.fetchall()
                self.assertEqual(len(observed), 4)
Esempio n. 5
0
    def test_create_kits_fail_nonexistent_project(self):
        with Transaction() as t:
            admin_repo = AdminRepo(t)

            with self.assertRaisesRegex(KeyError, "does not exist"):
                admin_repo.create_kits(5, 3, '', [10000, 10001])