test_config.py

# -*- coding: utf-8 -*-
"""
Unit tests for the Drycc api app.

Run the tests with "./manage.py test api"
"""
import copy
from io import StringIO
from django.contrib.auth import get_user_model
from django.core.cache import cache
from django.core.management import call_command

from unittest import mock

from api.models.app import App
from api.models.base import PTYPE_RUN, PTYPE_WEB
from api.models.config import Config
from api.serializers import CONFIG_LIMITS_MISMATCH_MSG
from api.models.build import Build
from api.models.release import Release

from api.tests import adapter, DryccTransactionTestCase
import requests_mock

User = get_user_model()


@requests_mock.Mocker(real_http=True, adapter=adapter)
class ConfigTest(DryccTransactionTestCase):
    """Tests setting and updating config values"""

    fixtures = ['tests.json']

    def setUp(self):
        self.user = User.objects.get(username='autotest')
        self.token = self.get_or_create_token(self.user)
        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token)

        url = '/v2/apps'
        response = self.client.post(url, HTTP_AUTHORIZATION='token {}'.format(self.token))
        self.assertEqual(response.status_code, 201, response.data)
        self.app = App.objects.all()[0]

    def tearDown(self):
        # make sure every test has a clean slate for k8s mocking
        cache.clear()

    def test_config(self, mock_requests):
        """
        Test that config is auto-created for a new app and that
        config can be updated using a PATCH
        """
        app_id = self.create_app()

        # check to see that an initial/empty config was created
        url = f"/v2/apps/{app_id}/config"
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200, response.data)
        self.assertIn('values', response.data)
        self.assertEqual(response.data['values'], [])
        config1 = response.data

        # set an initial config value
        value1 = {"name": "NEW_URL1", "value": "http://localhost:8080/", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        config2 = response.data
        self.assertNotEqual(config1['uuid'], config2['uuid'])
        self.assertEqual(body['values'], response.data['values'])

        # read the config
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200, response.data)
        config3 = response.data
        self.assertEqual(config2, config3)
        self.assertEqual(body['values'], response.data['values'])

        # set an additional config value
        value2 = {"name": "NEW_URL2", "value": "http://localhost:8080/", "group": "global"}
        body = {'values': [value2]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        config3 = response.data
        self.assertNotEqual(config2['uuid'], config3['uuid'])
        self.assertEqual([value1, value2], response.data['values'])

        # read the config again
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200, response.data)
        config4 = response.data
        self.assertEqual(config3, config4)
        self.assertEqual([value1, value2], response.data['values'])

        # unset a config value
        value2['value'] = None
        body = {'values': [value2]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        config5 = response.data
        self.assertNotEqual(config4['uuid'], config5['uuid'])
        self.assertEqual([value1], response.data['values'])

        # unset all config values
        value1['value'] = None
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([], response.data['values'])

        # set a port and then unset it to make sure validation ignores the unset
        value3 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {'values': [value3]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value3], response.data['values'])

        value3['value'] = None
        body = {'values': [value3]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([], response.data['values'])
        # repeat settings
        value2['value'] = "VALUE2"
        value3['value'] = None
        body = {'values': [value2, value3]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value2], response.data['values'])
        # set empty env
        value1['value'] = ''
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value2, value1], response.data['values'])

        # disallow put/patch
        response = self.client.put(url)
        self.assertEqual(response.status_code, 405, response.data)
        response = self.client.patch(url)
        self.assertEqual(response.status_code, 405, response.data)
        return config5

    def test_registry_set(self, mock_requests):
        app_id = self.create_app()
        # set an initial config value
        url = f"/v2/apps/{app_id}/config"
        web_registry = {'web': {'username': 'admin', 'password': 'admin'}}
        body = {'registry': web_registry}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)

        url = '/v2/apps/{}/config'.format(app_id)
        response = self.client.get(url)
        self.assertEqual(response.data['registry'], web_registry, response.data)

        task_registry = {'task': {'username': 'admin', 'password': 'admin'}}
        body = {'registry': task_registry}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)

        url = '/v2/apps/{}/config'.format(app_id)
        response = self.client.get(url)
        all_registry = {}
        all_registry.update(web_registry)
        all_registry.update(task_registry)
        self.assertEqual(response.data['registry'], all_registry, response.data)

        # delete task username
        task_registry = {'task': {'username': None, 'password': 'admin'}}
        body = {'registry': task_registry}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        url = '/v2/apps/{}/config'.format(app_id)
        response = self.client.get(url)
        all_registry = {}
        all_registry.update(web_registry)
        all_registry.update(task_registry)
        del all_registry['task']['username']
        self.assertEqual(response.data['registry'], all_registry, response.data)

        # delete task registry
        task_registry = {'task': None}
        body = {'registry': task_registry}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        url = '/v2/apps/{}/config'.format(app_id)
        response = self.client.get(url)
        self.assertEqual(response.data['registry'], web_registry, response.data)

    def test_values_refs(self, mock_requests):
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"
        values = [{"name": "DEBUG", "value": "true", "group": "global"}]
        body = {'values': values}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        self.assertEqual(config.envs("web"), {'DEBUG': 'true'})
        self.assertEqual(config.envs("task"), {'DEBUG': 'true'})

        # add test error, changed nothing
        values = [
            {"name": "DEBUG", "value": "true", "group": "global"},
        ]
        body = {'values': values}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 409, response.data)

        # add values ok
        values = [
            {"name": "DEBUG", "value": "true", "group": "mytask1"},
            {"name": "APP", "value": "task2", "group": "mytask2"},
            {"name": "DEBUG", "value": "false", "group": "global"},
        ]
        body = {'values': values}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        self.assertEqual(config.envs("web"), {'DEBUG': 'false'})
        self.assertEqual(config.envs("task"), {'DEBUG': 'false'})

        # add values_refs
        body = {'values_refs': {"task": ["mytask1", "mytask2"]}}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        self.assertEqual(config.envs("web"), {'DEBUG': 'false'})
        self.assertEqual(config.envs("task"), {'DEBUG': 'true', 'APP': 'task2'})

        # add new item for mytask
        values = [
            {"name": "VERSION", "value": "1.0.1", "group": "mytask1"},
        ]
        body = {'values': values}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        self.assertEqual(config.envs("web"), {'DEBUG': 'false'})
        self.assertEqual(
            config.envs("task"), {'DEBUG': 'true', 'VERSION': '1.0.1', 'APP': 'task2'})

        # remove tas values_refs
        body = {'values_refs': {'task': ['mytask1']}}
        response = self.client.delete(url, body)
        self.assertEqual(response.status_code, 200, response.data)
        url = '/v2/apps/{}/config'.format(app_id)
        response = self.client.get(url)
        self.assertEqual(response.data['values_refs'], {"task": ["mytask2"]}, response.data)

    def test_response_data(self, mock_requests):
        """Test that the serialized response contains only relevant data."""
        app_id = self.create_app()

        url = f"/v2/apps/{app_id}/config"

        # set an initial config value
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        for key in response.data:
            self.assertIn(key, ['uuid', 'owner', 'created', 'updated', 'app', 'values',
                                'values_refs', 'limits', 'tags', 'registry', 'healthcheck',
                                'lifecycle_post_start', 'lifecycle_pre_stop',
                                'termination_grace_period'])
        expected = {
            'owner': self.user.username,
            'app': app_id,
            'values': [value1],
            'limits': {
                PTYPE_RUN: 'std1.large.c1m1',
                PTYPE_WEB: 'std1.large.c1m1'
            },
            'tags': {},
            'registry': {}
        }
        self.assertEqual(response.data, response.data | expected)

    def test_response_data_types_converted(self, mock_requests):
        """Test that config data is converted into the correct type."""
        app_id = self.create_app()

        url = f"/v2/apps/{app_id}/config"
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {
            'values': [value1],
            'limits': {
                PTYPE_WEB: 'std1.large.c1m2',
            }
        }
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        for key in response.data:
            self.assertIn(key, ['uuid', 'owner', 'created', 'updated', 'app', 'values', 'limits',
                                'values_refs', 'tags', 'registry', 'healthcheck',
                                'lifecycle_post_start', 'lifecycle_pre_stop',
                                'termination_grace_period'])
        expected = {
            'owner': self.user.username,
            'app': app_id,
            'values': [value1],
            'limits': {
                PTYPE_RUN: 'std1.large.c1m1',
                PTYPE_WEB: 'std1.large.c1m2'
            },
            'tags': {},
            'registry': {}
        }
        self.assertEqual(response.data, expected | response.data)

        body = {'limits': {PTYPE_WEB: "not-exist"}}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 400, response.data)
        self.assertEqual(
            str(response.data["limits"][0]),
            CONFIG_LIMITS_MISMATCH_MSG.format("not-exist")
        )

    def test_config_set_same_key(self, mock_requests):
        """
        Test that config sets on the same key function properly
        """
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"

        # set an initial config value
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])

        # reset same config value
        value1['value'] = '5001'
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])

    def test_config_set_unicode(self, mock_requests):
        """
        Test that config sets with unicode values are accepted.
        """
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"

        # set an initial config value
        value1 = {"name": "POWERED_BY", "value": "Деис", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])
        # reset same config value
        value1['value'] = 'Кроликов'
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])

        # set an integer to test unicode regression
        value2 = {"name": "INTEGER", "value": "1", "group": "global"}
        body = {'values': [value2]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1, value2], response.data['values'])

    def test_config_str(self, mock_requests):
        """Test the text representation of a node."""
        config5 = self.test_config()
        config = Config.objects.get(uuid=config5['uuid'])
        self.assertEqual(str(config), "{}-{}".format(config5['app'], str(config5['uuid'])[:7]))

    def test_valid_config_keys(self, mock_requests):
        """Test that valid config keys are accepted.
        """
        keys = ("FOO", "_foo", "f001", "FOO_BAR_BAZ_")
        app_id = self.create_app()
        url = f'/v2/apps/{app_id}/config'
        values = []
        for k in keys:
            value1 = {"name": k, "value": "testvalue", "group": "global"}
            values.append(value1)
            body = {'values': [value1]}
            response = self.client.post(url, body)
            self.assertEqual(response.status_code, 201)
            self.assertEqual(values, response.data['values'])

    def test_config_deploy_failure(self, mock_requests):
        """
        Cause an Exception in app.deploy to cause a release.delete
        """
        app_id = self.create_app()

        # deploy app to get a build
        url = "/v2/apps/{}/build".format(app_id)
        body = {'image': 'autotest/example', 'stack': 'container'}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual(response.data['image'], body['image'])

        with mock.patch('api.models.app.App.deploy') as mock_deploy:
            mock_deploy.side_effect = Exception('Boom!')
            url = f'/v2/apps/{app_id}/config'
            value1 = {"name": "test", "value": "testvalue", "group": "global"}
            body = {'values': [value1]}
            response = self.client.post(url, body)
            self.assertEqual(response.status_code, 201)
            app = App.objects.get(id=app_id)
            release = app.release_set.latest()
            self.assertEqual(release.failed, True)
            self.assertEqual(release.conditions[0]['exception'], "Boom!")

    def test_invalid_config_keys(self, mock_requests):
        """Test that invalid config keys are rejected.
        """
        keys = ("$123", "../../foo", "FOO/", "*FOO-BAR")
        app_id = self.create_app()
        url = f'/v2/apps/{app_id}/config'
        for k in keys:
            value1 = {"name": k, "value": "testvalue", "group": "global"}
            body = {'values': [value1]}
            response = self.client.post(url, body)
            self.assertEqual(response.status_code, 400)

    def test_invalid_config_values(self, mock_requests):
        """
        Test that invalid config values are rejected.
        Right now only PORT is checked
        """
        data = [
            {"name": "PORT", "value": "dog", "group": "global"},
            {"name": "PORT", "value": "99999", "group": "global"}
        ]
        app_id = self.create_app()
        url = f'/v2/apps/{app_id}/config'
        for row in data:
            body = {'values': [row]}
            response = self.client.post(url, body)
            self.assertEqual(response.status_code, 400, response.data)

    def test_admin_can_create_config_on_other_apps(self, mock_requests):
        """If a non-admin creates an app, an administrator should be able to set config
        values for that app.
        """
        user = User.objects.get(username='autotest2')
        token = self.get_or_create_token(user)

        self.client.credentials(HTTP_AUTHORIZATION='Token ' + token)
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"

        # set an initial config value
        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token)
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])
        return response

    def test_config_owner_is_requesting_user(self, mock_requests):
        """
        Ensure that setting the config value is owned by the requesting user
        See https://github.com/drycc/drycc/issues/2650
        """
        response = self.test_admin_can_create_config_on_other_apps()
        self.assertEqual(response.data['owner'], self.user.username)

    def test_unauthorized_user_cannot_modify_config(self, mock_requests):
        """
        An unauthorized user should not be able to modify other config.

        Since an unauthorized user can't access the application, these
        requests should return a 403.
        """
        app_id = self.create_app()

        unauthorized_user = User.objects.get(username='autotest2')
        unauthorized_token = self.get_or_create_token(unauthorized_user)
        self.client.credentials(HTTP_AUTHORIZATION='Token ' + unauthorized_token)
        url = '/v2/apps/{}/config'.format(app_id)
        value1 = {"name": "FOO", "value": "bar", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 403)

    def test_config_app_not_exists(self, mock_requests):
        url = '/v2/apps/{}/config'.format('fake')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 404)
        self.assertEqual(response.data, 'No App matches the given query.')

    def test_config_failures(self, mock_requests):
        app_id = self.create_app()
        app = App.objects.get(id=app_id)

        # deploy app to get a build
        url = "/v2/apps/{}/build".format(app_id)
        body = {'image': 'autotest/example', 'stack': 'container'}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual(response.data['image'], body['image'])

        # set an initial config value
        url = f"/v2/apps/{app_id}/config"
        value1 = {"name": "NEW_URL1", "value": "http://localhost:8080/", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])
        success_config = app.release_set.latest().config

        # create a failed config to check that failed release is created
        with mock.patch('api.models.app.App.deploy') as mock_deploy:
            mock_deploy.side_effect = Exception('Boom!')
            url = f'/v2/apps/{app_id}/config'
            value1 = {"name": "test", "value": "testvalue", "group": "global"}
            body = {'values': [value1]}
            response = self.client.post(url, body)
            self.assertEqual(response.status_code, 201)
            self.assertEqual(app.release_set.latest().version, 4)
            self.assertEqual(app.release_set.latest().failed, True)
            self.assertEqual(app.release_set.latest().conditions[0]['exception'], "Boom!")
            self.assertEqual(app.release_set.filter(failed=False).latest().version, 3)

        # create a build to see that the new release is created with the last successful config
        url = "/v2/apps/{}/build".format(app_id)
        body = {'image': 'autotest/example', 'stack': 'container'}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual(app.release_set.latest().version, 5)
        self.assertEqual(app.release_set.latest().config, success_config)
        self.assertEqual(app.config_set.count(), 3)

    def test_unset_limits(self, mock_requests):
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {
            'values': [value1],
            'limits': {
                "task": 'std1.large.c2m4',
                PTYPE_RUN: 'std1.large.c2m4',
                PTYPE_WEB: 'std1.large.c2m4',
            },
        }
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data["limits"], body["limits"])
        # unset ok
        body = {
            'limits': {
                  "task": None,
            },
        }
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201)
        response = self.client.get(url)
        self.assertEqual(
            response.data["limits"],
            {PTYPE_RUN: 'std1.large.c2m4', PTYPE_WEB: 'std1.large.c2m4'},
        )

    def test_unset_limits_error(self, mock_requests):
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {
            'values': [value1],
            'limits': {
                "task": 'std1.large.c2m4',
                PTYPE_RUN: 'std1.large.c2m4',
                PTYPE_WEB: 'std1.large.c2m4',
            },
        }
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201)
        # dockerfile + procfile worflow
        app = App.objects.get(id=app_id)
        user = User.objects.get(username='autotest')
        build = Build.objects.create(
            owner=user,
            app=app,
            image="qwerty",
            procfile={
                'web': 'node server.js',
                'worker': 'node worker.js'
            },
            dockerfile='foo',
            sha='somereallylongsha'
        )
        # create an initial release
        release = Release.objects.create(
            version=3,
            owner=user,
            app=app,
            config=app.config_set.latest(),
            build=build
        )
        # deploy
        release.deploy()
        # unset error
        body = {
            'limits': {
                  "no-exists": None,
            },
        }
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 422)
        self.assertEqual(str(response.data["detail"]), "no-exists does not exist under limits")
        # scale up
        body = {'web': 3}
        response = self.client.post(f"/v2/apps/{app_id}/ptypes/scale", body)
        self.assertEqual(response.status_code, 204, response.data)

        body = {
            'limits': {
                  PTYPE_WEB: None,
            },
        }
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 422)
        self.assertEqual(
            str(response.data["detail"]), "the web has already been used and cannot be deleted")

    def call_command(self, *args, **kwargs):
        out = StringIO()
        call_command(
            "measure_apps",
            *args,
            stdout=out,
            stderr=StringIO(),
            **kwargs,
        )
        return out.getvalue()

    def test_measure_config(self, *args, **kwargs):
        # create
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {
            'values': [value1],
            'limits': {
                  PTYPE_RUN: 'std1.large.c2m4',
                  PTYPE_WEB: 'std1.large.c2m4',
            },
        }
        response = self.client.post(url, body)
        out = self.call_command()
        self.assertIn(out, "done\n")
        self.assertEqual(response.status_code, 201)

    def test_set_config_limits_run(self, *args, **kwargs):
        # create
        app_id = self.create_app()
        # dockerfile + procfile worflow
        app = App.objects.get(id=app_id)
        user = User.objects.get(username='autotest')
        build = Build.objects.create(
            owner=user,
            app=app,
            image="qwerty",
            procfile={
                'web': 'node server.js',
                'worker': 'node worker.js'
            },
            dockerfile='foo',
            sha='somereallylongsha'
        )
        # create an initial release
        release = Release.objects.create(
            version=3,
            owner=user,
            app=app,
            config=app.config_set.latest(),
            build=build
        )
        # deploy
        release.deploy()
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {
            'values': [value1],
            'limits': {
                  PTYPE_RUN: 'std1.large.c2m4',
                  PTYPE_WEB: 'std1.large.c2m4',
            },
        }
        url = f"/v2/apps/{app_id}/config"
        response = self.client.post(url, body)
        url = f"/v2/apps/{app_id}/config"
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200, response.data)
        expect = {'run': 'std1.large.c2m4', 'web': 'std1.large.c2m4', 'worker': 'std1.large.c1m1'}
        self.assertEqual(expect, response.json()["limits"], response.data)

    def test_config_set_typed_values(self, mock_requests):
        """
        Test that config sets on the same key function properly
        """
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"

        # set an initial config value
        body = {'values': [{"name": "PORT", "value": "5000", "ptype": "web"}]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertIn({"name": "PORT", "value": "5000", "ptype": "web"}, response.data['values'])

        # reset same config value
        body = {'values': [{"name": "PORT", "value": "5001", "ptype": "web"}]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertIn({"name": "PORT", "value": "5001", "ptype": "web"}, response.data['values'])
        # unset PORT
        body = {'values': [{"name": "PORT", "value": None, "ptype": "web"}]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual(response.data['values'], [], response.data)

    def test_config_version(self, mock_requests):
        """
        Test that config sets on the same key function properly
        """
        app_id = self.create_app()
        url = f"/v2/apps/{app_id}/config"

        # set an initial config value
        value1 = {"name": "PORT", "value": "5000", "group": "global"}
        body = {'values': [value1]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1], response.data['values'])
        url = f"/v2/apps/{app_id}/config"

        # set config NAME
        value2 = {"name": "NAME", "value": "drycc", "group": "global"}
        body = {'values': [value2]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1, value2], response.data['values'])

        # set config WEBSITE
        value3 = {"name": "WEBSITE", "value": "www.drycc.cc", "group": "global"}
        body = {'values': [value3]}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        self.assertEqual([value1, value2, value3], response.data['values'])

        url = f"/v2/apps/{app_id}/config/?version=v2"
        response = self.client.get(url)
        self.assertEqual(response.data['values'], [value1], response.data)

        url = f"/v2/apps/{app_id}/config/?version=v3"
        response = self.client.get(url)
        self.assertEqual(
            response.data['values'], [value1, value2], response.data)

        url = f"/v2/apps/{app_id}/config/?version=v4"
        response = self.client.get(url)
        self.assertEqual(
            response.data['values'],
            [value1, value2, value3], response.data)

    def test_diff_ptypes(self, mock_requests):
        app_id = self.create_app()
        value1 = {"name": "WEBSITE", "value": "www.drycc.cc", "group": "global"}
        body = {'values': [value1]}
        url = f"/v2/apps/{app_id}/config"
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        old_config = config.previous()
        self.assertEqual(config.diff_ptypes(old_config, ["web", "task"]), {"web", "task"})

        # add value
        value1 = {"name": "DEBUG", "value": "true", "group": "mygroup"}
        body = {'values': [value1]}
        url = f"/v2/apps/{app_id}/config"
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        old_config = config.previous()
        self.assertEqual(config.diff_ptypes(old_config, ["web", "task"]), set())

        # add group ref
        body = {'values_refs': {"task": ["mygroup"]}}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        old_config = config.previous()
        self.assertEqual(config.diff_ptypes(old_config, ["web", "task"]), {"task"})
        # add new group
        value1 = {"name": "DEBUG", "value": "true", "group": "mygroup1"}
        body = {'values': [value1]}
        url = f"/v2/apps/{app_id}/config"
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)

        body = {'values_refs': {"task": ["mygroup1"]}}
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        uuid = response.data["uuid"]
        config = Config.objects.get(uuid=uuid)
        old_config = config.previous()
        self.assertEqual(config.diff_ptypes(old_config, ["web", "task"]), {"task"})
        self.assertEqual(config.envs("task"), {'WEBSITE': 'www.drycc.cc', 'DEBUG': 'true'})

    def test_config_from_dryccfile(self, mock_requests):
        app_id = self.create_app()
        app = App.objects.get(id=app_id)
        build_body = {
            'image': 'autotest/example',
            'stack': 'heroku-18',
            'sha': 'a'*40,
            'dryccfile': {
                "build": {
                    "docker": {"web": "Dockerfile", "worker": "worker/Dockerfile"},
                    "config": [
                        {"name": "FOO", "value": "bar"},
                        {"name": "RAILS_ENV", "value": "development"},
                    ],
                },
                'deploy': {
                    'web': {
                        'image': "127.0.0.1/cat/cat"
                    },
                }
            },
        }
        with mock.patch('scheduler.resources.pod.Pod.watch') as mock_kube:
            mock_kube.return_value = ['up', 'down']
            url = f"/v2/apps/{app_id}/build"
            response = self.client.post(url, build_body)
            self.assertEqual(response.status_code, 201, response.data)
        value1 = {"name": "WEBSITE", "value": "www.drycc.cc", "group": "global"}
        body = {'values': [value1]}
        url = f"/v2/apps/{app_id}/config"
        response = self.client.post(url, body)
        self.assertEqual(response.status_code, 201, response.data)
        release = app.release_set.latest()
        self.assertEqual(release.failed, False)
        self.assertEqual(release.config.envs("web"), {"WEBSITE": "www.drycc.cc"})
        # set env by dryccfile
        build_body['dryccfile']['config'] = [
            {"name": "GROUP", "group": "mygroup1", "value": "g1"},
            {"name": "DEBUG", "group": "mygroup1", "value": "tr"},
            {"name": "TEST1", "group": "mygroup2", "value": "g1"},
            {"name": "TEST2", "group": "mygroup2", "value": "tr"},
        ]
        build_body['dryccfile']['deploy']['web']['config'] = {
            'env': [
                {'name': "PENV1", 'value': 'web'},
                {'name': "PENV2", 'value': 'web'},
            ],
            'ref': ['mygroup1', 'mygroup2']
        }
        with mock.patch('scheduler.resources.pod.Pod.watch') as mock_kube:
            mock_kube.return_value = ['up', 'down']
            url = f"/v2/apps/{app_id}/build"
            response = self.client.post(url, build_body)
            self.assertEqual(response.status_code, 201, response.data)

        release = app.release_set.latest()
        self.assertEqual(release.failed, False)
        self.assertEqual(
            release.config.envs("web"),
            {
                'GROUP': 'g1', 'DEBUG': 'tr', 'TEST1': 'g1', 'TEST2': 'tr', 'PENV1': 'web',
                'PENV2': 'web', "WEBSITE": "www.drycc.cc",
            }
        )
        build_body['dryccfile']['deploy']['web']['healthcheck'] = {
            'livenessProbe': {
                'httpGet': {
                    'path': '/healthz',
                    'port': 8080,
                },
                'initialDelaySeconds': 3,
                'periodSeconds': 3,
            }
        }
        with mock.patch('scheduler.resources.pod.Pod.watch') as mock_kube:
            mock_kube.return_value = ['up', 'down']
            url = f"/v2/apps/{app_id}/build"
            response = self.client.post(url, build_body)
            self.assertEqual(response.status_code, 201, response.data)

        release = app.release_set.latest()
        self.assertEqual(release.failed, False)
        self.assertEqual(
            release.config.healthcheck['web'],
            build_body['dryccfile']['deploy']['web']['healthcheck'],
        )
        # test use old config and healthcheck
        new_build_body = copy.deepcopy(build_body)
        del new_build_body['dryccfile']['config']
        del new_build_body['dryccfile']['deploy']['web']['config']
        del new_build_body['dryccfile']['deploy']['web']['healthcheck']
        with mock.patch('scheduler.resources.pod.Pod.watch') as mock_kube:
            mock_kube.return_value = ['up', 'down']
            url = f"/v2/apps/{app_id}/build"
            response = self.client.post(url, new_build_body)
            self.assertEqual(response.status_code, 201, response.data)
        release = app.release_set.latest()
        self.assertEqual(release.failed, False)
        self.assertEqual(release.config.healthcheck, release.previous().config.healthcheck)
        self.assertEqual(release.config.values, release.previous().config.values)
        self.assertEqual(release.config.values_refs, release.previous().config.values_refs)
        # set empty
        new_build_body = copy.deepcopy(build_body)
        new_build_body['dryccfile']['config'] = []
        new_build_body['dryccfile']['deploy']['web']['config'] = {}
        new_build_body['dryccfile']['deploy']['web']['healthcheck'] = {}
        with mock.patch('scheduler.resources.pod.Pod.watch') as mock_kube:
            mock_kube.return_value = ['up', 'down']
            url = f"/v2/apps/{app_id}/build"
            response = self.client.post(url, new_build_body)
            self.assertEqual(response.status_code, 201, response.data)
        release = app.release_set.latest()
        self.assertEqual(release.failed, False)
        self.assertEqual(release.config.healthcheck, {'web': {}})
        self.assertEqual(release.config.envs("web"), {"WEBSITE": "www.drycc.cc"})
        self.assertEqual(release.config.values_refs, {})