tests.py

'''
Tests of django_plotly_dash.

These tests can be directly used or imported into eg the tests of the demo app.

The use of pytest is assumed.

Copyright (c) 2018 Gibbs Consulting and others - see CONTRIBUTIONS.md

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

'''

import json
from unittest.mock import patch

import pytest
# pylint: disable=bare-except
from dash.dependencies import Input, State, Output
from django.urls import reverse

from django_plotly_dash import DjangoDash
from django_plotly_dash.dash_wrapper import get_local_stateless_list, get_local_stateless_by_name
from django_plotly_dash.models import DashApp, find_stateless_by_name
from django_plotly_dash.tests_dash_contract import fill_in_test_app, dash_contract_data


def test_dash_app():
    'Test the import and formation of the dash app orm wrappers'

    from django_plotly_dash.models import StatelessApp
    stateless_a = StatelessApp(app_name="Some name")

    assert stateless_a
    assert stateless_a.app_name
    assert str(stateless_a) == stateless_a.app_name


@pytest.mark.django_db
def test_dash_stateful_app_client_contract(client):
    'Test the state management of a DashApp as well as the contract between the client and the Dash app'

    from django_plotly_dash.models import StatelessApp

    # create a DjangoDash, StatelessApp and DashApp
    ddash = DjangoDash(name="DDash")
    fill_in_test_app(ddash, write=False)

    stateless_a = StatelessApp(app_name="DDash")
    stateless_a.save()
    stateful_a = DashApp(stateless_app=stateless_a,
                         instance_name="Some name",
                         slug="my-app", save_on_change=True)
    stateful_a.save()

    # check app can be found back
    assert "DDash" in get_local_stateless_list()
    assert get_local_stateless_by_name("DDash") == ddash
    assert find_stateless_by_name("DDash") == ddash

    # check the current_state is empty
    assert stateful_a.current_state() == {}

    # set the initial expected state
    expected_state = {'inp1': {'n_clicks': 0, 'n_clicks_timestamp': 1611733453854},
                      'inp1b': {'n_clicks': 5, 'n_clicks_timestamp': 1611733454354},
                      'inp2': {'n_clicks': 7, 'n_clicks_timestamp': 1611733454554},
                      'out1-0': {'n_clicks': 1, 'n_clicks_timestamp': 1611733453954},
                      'out1-1': {'n_clicks': 2, 'n_clicks_timestamp': 1611733454054},
                      'out1-2': {'n_clicks': 3, 'n_clicks_timestamp': 1611733454154},
                      'out1-3': {'n_clicks': 4, 'n_clicks_timestamp': 1611733454254},
                      'out1b': {'href': 'http://www.example.com/null',
                                'n_clicks': 6,
                                'n_clicks_timestamp': 1611733454454},
                      'out2-0': {'n_clicks': 8, 'n_clicks_timestamp': 1611733454654},
                      'out3': {'n_clicks': 12, 'n_clicks_timestamp': 1611733455054},
                      'out4': {'n_clicks': 16, 'n_clicks_timestamp': 1611733455454},
                      'out5': {'n_clicks': 20, 'n_clicks_timestamp': 1611733455854},
                      '{"_id":"inp-0","_type":"btn3"}': {'n_clicks': 9,
                                                         'n_clicks_timestamp': 1611733454754},
                      '{"_id":"inp-0","_type":"btn4"}': {'n_clicks': 13,
                                                         'n_clicks_timestamp': 1611733455154},
                      '{"_id":"inp-0","_type":"btn5"}': {'n_clicks': 17,
                                                         'n_clicks_timestamp': 1611733455554},
                      '{"_id":"inp-1","_type":"btn3"}': {'n_clicks': 10,
                                                         'n_clicks_timestamp': 1611733454854},
                      '{"_id":"inp-1","_type":"btn4"}': {'n_clicks': 14,
                                                         'n_clicks_timestamp': 1611733455254},
                      '{"_id":"inp-1","_type":"btn5"}': {'n_clicks': 18,
                                                         'n_clicks_timestamp': 1611733455654},
                      '{"_id":"inp-2","_type":"btn3"}': {'n_clicks': 11,
                                                         'n_clicks_timestamp': 1611733454954},
                      '{"_id":"inp-2","_type":"btn4"}': {'n_clicks': 15,
                                                         'n_clicks_timestamp': 1611733455354},
                      '{"_id":"inp-2","_type":"btn5"}': {'n_clicks': 19,
                                                         'n_clicks_timestamp': 1611733455754}}

    ########## test state management of the app and conversion of components ids
    # search for state values in dash layout
    stateful_a.populate_values()
    assert stateful_a.current_state() == expected_state
    assert stateful_a.have_current_state_entry("inp1", "n_clicks")
    assert stateful_a.have_current_state_entry({"_type": "btn3", "_id": "inp-0"}, "n_clicks_timestamp")
    assert stateful_a.have_current_state_entry('{"_id":"inp-0","_type":"btn3"}', "n_clicks_timestamp")
    assert not stateful_a.have_current_state_entry("checklist", "other-prop")

    # update a non existent state => no effect on current_state
    stateful_a.update_current_state("foo", "value", "random")
    assert stateful_a.current_state() == expected_state

    # update an existent state => update current_state
    stateful_a.update_current_state('{"_id":"inp-2","_type":"btn5"}', "n_clicks", 100)
    expected_state['{"_id":"inp-2","_type":"btn5"}'] = {'n_clicks': 100, 'n_clicks_timestamp': 1611733455754}
    assert stateful_a.current_state() == expected_state

    assert DashApp.objects.get(instance_name="Some name").current_state() == {}

    stateful_a.handle_current_state()

    assert DashApp.objects.get(instance_name="Some name").current_state() == expected_state

    # check initial layout serve has the correct values injected
    dash_instance = stateful_a.as_dash_instance()
    resp = dash_instance.serve_layout()

    # initialise layout with app state
    layout, mimetype = dash_instance.augment_initial_layout(resp, {})
    assert '"n_clicks": 100' in layout

    # initialise layout with initial arguments
    layout, mimetype = dash_instance.augment_initial_layout(resp, {
        '{"_id":"inp-2","_type":"btn5"}': {"n_clicks": 200}})
    assert '"n_clicks": 100' not in layout
    assert '"n_clicks": 200' in layout

    ########### test contract between client and app by replaying interactions recorded in tests_dash_contract.json
    # get update component route
    url = reverse('the_django_plotly_dash:update-component', kwargs={'ident': 'my-app'})

    # for all interactions in the tests_dash_contract.json
    for scenario in json.load(dash_contract_data.open("r")):
        body = scenario["body"]

        response = client.post(url, json.dumps(body), content_type="application/json")

        assert response.status_code == 200

        response = json.loads(response.content)

        # compare first item in response with first result
        result = scenario["result"]
        if isinstance(result, list):
            result = result[0]
        content = response["response"].popitem()[1].popitem()[1]
        assert content == result

        # handle state
        stateful_a.handle_current_state()

    # check final state has been changed accordingly
    final_state = {'inp1': {'n_clicks': 1, 'n_clicks_timestamp': 1615103027288},
                   'inp1b': {'n_clicks': 5, 'n_clicks_timestamp': 1615103033482},
                   'inp2': {'n_clicks': 8, 'n_clicks_timestamp': 1615103036591},
                   'out1-0': {'n_clicks': 1, 'n_clicks_timestamp': 1611733453954},
                   'out1-1': {'n_clicks': 2, 'n_clicks_timestamp': 1611733454054},
                   'out1-2': {'n_clicks': 3, 'n_clicks_timestamp': 1611733454154},
                   'out1-3': {'n_clicks': 4, 'n_clicks_timestamp': 1611733454254},
                   'out1b': {'href': 'http://www.example.com/1615103033482',
                             'n_clicks': 6,
                             'n_clicks_timestamp': 1611733454454},
                   'out2-0': {'n_clicks': 8, 'n_clicks_timestamp': 1611733454654},
                   'out3': {'n_clicks': 12, 'n_clicks_timestamp': 1611733455054},
                   'out4': {'n_clicks': 16, 'n_clicks_timestamp': 1611733455454},
                   'out5': {'n_clicks': 20, 'n_clicks_timestamp': 1611733455854},
                   '{"_id":"inp-0","_type":"btn3"}': {'n_clicks': 10,
                                                      'n_clicks_timestamp': 1615103039030},
                   '{"_id":"inp-0","_type":"btn4"}': {'n_clicks': 14,
                                                      'n_clicks_timestamp': 1611733455154},
                   '{"_id":"inp-0","_type":"btn5"}': {'n_clicks': 18,
                                                      'n_clicks_timestamp': 1611733455554},
                   '{"_id":"inp-1","_type":"btn3"}': {'n_clicks': 11,
                                                      'n_clicks_timestamp': 1615103039496},
                   '{"_id":"inp-1","_type":"btn4"}': {'n_clicks': 15,
                                                      'n_clicks_timestamp': 1611733455254},
                   '{"_id":"inp-1","_type":"btn5"}': {'n_clicks': 19,
                                                      'n_clicks_timestamp': 1611733455654},
                   '{"_id":"inp-2","_type":"btn3"}': {'n_clicks': 12,
                                                      'n_clicks_timestamp': 1615103040528},
                   '{"_id":"inp-2","_type":"btn4"}': {'n_clicks': 15,
                                                      'n_clicks_timestamp': 1611733455354},
                   '{"_id":"inp-2","_type":"btn5"}': {'n_clicks': 20,
                                                      'n_clicks_timestamp': 1611733455754}}

    assert DashApp.objects.get(instance_name="Some name").current_state() == final_state



def test_dash_callback_arguments():
    'Test the flexibility of the callback arguments order (handling of inputs/outputs/states)'

    # create a DjangoDash
    ddash = DjangoDash(name="DashCallbackArguments")

    # add a callback with the new flexible order of dependencies
    @ddash.callback(
        Output("one", "foo"),
        Output("two", "foo"),
        Input("one", "baz"),
        Input("two", "baz"),
        Input("three", "baz"),
        State("one", "bil"),
    )
    def new():
        pass

    # add a callback with the old/classical flexible order of dependencies
    @ddash.callback(
        [Output("one", "foo"),
         Output("two", "foo")],
        [Input("one", "baz"),
         Input("two", "baz"),
         Input("three", "baz")],
        [State("one", "bil")]
    )
    def old():
        pass

    assert ddash._callback_sets == [({'inputs': [Input("one", "baz"),
                                                 Input("two", "baz"),
                                                 Input("three", "baz"), ],
                                      'output': [Output("one", "foo"),
                                                 Output("two", "foo")],
                                      'prevent_initial_call': None,
                                      'state': [State("one", "bil"), ]},
                                     new),
                                    ({'inputs': [Input("one", "baz"),
                                                 Input("two", "baz"),
                                                 Input("three", "baz"), ],
                                      'output': [Output("one", "foo"),
                                                 Output("two", "foo")],
                                      'prevent_initial_call': None,
                                      'state': [State("one", "bil"), ]},
                                     old)
                                    ]


def test_util_error_cases(settings):
    'Test handling of missing settings'

    settings.PLOTLY_DASH = None

    from django_plotly_dash.util import pipe_ws_endpoint_name, dpd_http_endpoint_root, http_endpoint, insert_demo_migrations

    assert pipe_ws_endpoint_name() == 'dpd/ws/channel'
    assert dpd_http_endpoint_root() == "dpd/views"
    assert http_endpoint("fred") == '^dpd/views/fred/$'
    assert not insert_demo_migrations()

    del settings.PLOTLY_DASH

    assert pipe_ws_endpoint_name() == 'dpd/ws/channel'
    assert dpd_http_endpoint_root() == "dpd/views"
    assert http_endpoint("fred") == '^dpd/views/fred/$'
    assert not insert_demo_migrations()


def test_demo_routing():
    'Test configuration options for the demo'

    from django_plotly_dash.util import pipe_ws_endpoint_name, insert_demo_migrations
    assert pipe_ws_endpoint_name() == 'ws/channel'
    assert insert_demo_migrations()


def test_local_serving(settings):
    'Test local serve settings'

    from django_plotly_dash.util import serve_locally, static_asset_root, full_asset_path
    # Now default to serving all files locally
    assert serve_locally() == True
    assert static_asset_root() == 'dpd/assets'
    assert full_asset_path('fred.jim', 'harry') == 'dpd/assets/fred/jim/harry'


@pytest.mark.django_db
def test_direct_access(client):
    'Check direct use of a stateless application using demo test data'

    from django.urls import reverse
    from .app_name import main_view_label

    for route_name in ['layout', 'dependencies', main_view_label]:
        for prefix, arg_map in [('app-', {'ident':'SimpleExample'}),
                                ('', {'ident':'simpleexample-1'}),]:
            url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

            response = client.get(url)

            assert response.content
            assert response.status_code == 200

    for route_name in ['routes',]:
        for prefix, arg_map in [('app-', {'ident':'SimpleExample'}),
                                ('', {'ident':'simpleexample-1'}),]:
            url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

            did_fail = False
            try:
                response = client.get(url)
            except:
                did_fail = True

            assert did_fail


@pytest.mark.django_db
def test_updating(client):
    'Check updating of an app using demo test data'

    from django.urls import reverse

    route_name = 'update-component'

    for prefix, arg_map in [('app-', {'ident':'SimpleExample'}),
                            ('', {'ident':'simpleexample-1'}),]:
        url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

        response = client.post(url, json.dumps({'output': 'output-size.children',
                                                'inputs':[{'id':'dropdown-color',
                                                           'property':'value',
                                                           'value':'blue'},
                                                          {'id':'dropdown-size',
                                                           'property':'value',
                                                           'value':'medium'},
                                                         ]}), content_type="application/json")

        assert response.content == b'{"response":{"output-size":{"children":"The chosen T-shirt is a medium blue one."}},"multi":true}'
        assert response.status_code == 200


@pytest.mark.django_db
def test_injection_app_access(client):
    'Check direct use of a stateless application using demo test data'

    from django.urls import reverse
    from .app_name import main_view_label

    for route_name in ['layout', 'dependencies', main_view_label]:
        for prefix, arg_map in [('app-', {'ident':'dash_example_1'}),
                                #('', {'ident':'simpleexample-1'}),
                               ]:
            url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

            response = client.get(url)

            assert response.content
            assert response.status_code == 200

    for route_name in ['routes',]:
        for prefix, arg_map in [('app-', {'ident':'dash_example_1'}),]:
            url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

            did_fail = False
            try:
                response = client.get(url)
            except:
                did_fail = True

            assert did_fail



@pytest.mark.django_db
def test_injection_updating_multiple_callbacks(client):
    'Check updating of an app using demo test data for multiple callbacks'

    from django.urls import reverse

    route_name = 'update-component'

    for prefix, arg_map in [('app-', {'ident':'multiple_callbacks'}),]:
        url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

        # output is now a string of id and propery
        response = client.post(url, json.dumps({'output':'..output-one.children...output-two.children...output-three.children..',
                                                'inputs':[
            {'id':'button',
             'property':'n_clicks',
             'value':'10'},
            {'id':'dropdown-color',
             'property':'value',
             'value':'purple-ish yellow with a hint of greeny orange'},
                                                         ]}), content_type="application/json")

        assert response.status_code == 200

        resp = json.loads(response.content.decode('utf-8'))
        assert 'response' in resp

        resp_detail = resp['response']
        assert 'output-two' in resp_detail
        assert 'children' in resp_detail['output-two']
        assert resp_detail['output-two']['children'] == "Output 2: 10 purple-ish yellow with a hint of greeny orange []"


@pytest.mark.django_db
def test_flexible_expanded_callbacks(client):
    'Check updating of an app using demo test data for flexible expanded callbacks'

    from django.urls import reverse

    route_name = 'update-component'

    for prefix, arg_map in [('app-', {'ident':'flexible_expanded_callbacks'}),]:
        url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

        # output contains all arguments of the expanded_callback
        response = client.post(url, json.dumps({'output':'output-one.children',
                                                'inputs':[
            {'id':'button',
             'property':'n_clicks',
             'value':'10'},
                                                         ]}), content_type="application/json")

        assert response.status_code == 200

        resp = json.loads(response.content.decode('utf-8'))
        for key in ["dash_app_id", "dash_app", "callback_context"]:
            assert key in resp["response"]['output-one']['children']

        # output contains all arguments of the expanded_callback
        response = client.post(url, json.dumps({'output':'output-two.children',
                                                'inputs':[
            {'id':'button',
             'property':'n_clicks',
             'value':'10'},
                                                         ]}), content_type="application/json")

        assert response.status_code == 200

        resp = json.loads(response.content.decode('utf-8'))
        assert resp["response"]=={'output-two': {'children': 'ok'}}


        # output contains all arguments of the expanded_callback
        response = client.post(url, json.dumps({'output':'output-three.children',
                                                'inputs':[
            {'id':'button',
             'property':'n_clicks',
             'value':'10'},
                                                         ]}), content_type="application/json")

        assert response.status_code == 200

        resp = json.loads(response.content.decode('utf-8'))
        assert resp["response"]=={"output-three": {"children": "flexible_expanded_callbacks"}}


@pytest.mark.django_db
def test_injection_updating(client):
    'Check updating of an app using demo test data'

    from django.urls import reverse

    route_name = 'update-component'

    for prefix, arg_map in [('app-', {'ident':'dash_example_1'}),]:
        url = reverse('the_django_plotly_dash:%s%s' % (prefix, route_name), kwargs=arg_map)

        response = client.post(url, json.dumps({#'output':{'id':'test-output-div', 'property':'children'},
                                                'output': "test-output-div.children",
                                                'inputs':[{'id':'my-dropdown1',
                                                           'property':'value',
                                                           'value':'TestIt'},
                                                         ]}), content_type="application/json")

        rStart = b'{"response":{"test-output-div":{"children":[{"props":{"id":"line-area-graph2"'

        assert response.content.startswith(rStart)
        assert response.status_code == 200

        # Single output callback, output=="component_id.component_prop"
        response = client.post(url, json.dumps({'output':'test-output-div.children',
                                                'inputs':[{'id':'my-dropdown1',
                                                           'property':'value',
                                                           'value':'TestIt'},
                                                         ]}), content_type="application/json")

        rStart = b'{"response":{"test-output-div":{"children":[{"props":{"id":"line-area-graph2"'

        assert response.content.startswith(rStart)
        assert response.status_code == 200

        # Single output callback, fails if output=="..component_id.component_prop.."
        with pytest.raises(KeyError, match="..test-output-div.children.."):
            client.post(url, json.dumps({'output':'..test-output-div.children..',
                                                'inputs':[{'id':'my-dropdown1',
                                                           'property':'value',
                                                           'value':'TestIt'},
                                                         ]}), content_type="application/json")


        # Multiple output callback, fails if output=="component_id.component_prop"
        with pytest.raises(KeyError, match="test-output-div3.children"):
            client.post(url, json.dumps({'output':'test-output-div3.children',
                                                'inputs':[{'id':'my-dropdown1',
                                                           'property':'value',
                                                           'value':'TestIt'},
                                                         ]}), content_type="application/json")

        # Multiple output callback, output=="..component_id.component_prop.."
        response = client.post(url, json.dumps({'output':'..test-output-div3.children..',
                                                'inputs':[{'id':'my-dropdown1',
                                                           'property':'value',
                                                           'value':'TestIt'},
                                                         ]}), content_type="application/json")

        rStart = b'{"response":{"test-output-div3":{"children":[{"props":{"id":"line-area-graph2"'

        assert response.content.startswith(rStart)
        assert response.status_code == 200

        with pytest.raises(KeyError, match="django_to_dash_context"):
            client.post(url, json.dumps({'output': 'test-output-div2.children',
                                         'inputs':[{'id':'my-dropdown2',
                                                    'property':'value',
                                                    'value':'TestIt'},
                                                  ]}), content_type="application/json")

        session = client.session
        session['django_plotly_dash'] = {'django_to_dash_context': 'Test 789 content'}
        session.save()

        response = client.post(url, json.dumps({'output': 'test-output-div2.children',
                                                 'inputs':[{'id':'my-dropdown2',
                                                            'property':'value',
                                                            'value':'TestIt'},
                                                          ]}), content_type="application/json")
        rStart = b'{"response":{"test-output-div2":{"children":[{"props":{"children":["You have '

        assert response.content.startswith(rStart)
        assert response.status_code == 200

        assert response.content.find(b'Test 789 content') > 0


@pytest.mark.django_db
def test_argument_settings(settings, client):
    'Test the setting that controls how initial arguments are propagated through to the dash app'

    from django_plotly_dash.util import initial_argument_location, store_initial_arguments, get_initial_arguments

    assert initial_argument_location()

    settings.PLOTLY_DASH = {'cache_arguments': True}

    assert initial_argument_location()

    test_value = {"test":"first"}

    cache_id = store_initial_arguments(None, test_value)

    assert len(cache_id) > 10

    fetched = get_initial_arguments(None, cache_id)

    assert fetched == test_value

    settings.PLOTLY_DASH = {'cache_arguments': False}

    assert not initial_argument_location()

    cache_id2 = store_initial_arguments(client, test_value)

    assert len(cache_id2) > 10

    assert cache_id != cache_id2

    ## For some reason, sessions are continually replaced, so lookup here doesnt work
    #fetched2 = get_initial_arguments(client, cache_id2)
    #assert fetched2 == test_value

    assert store_initial_arguments(None, None) is None
    assert get_initial_arguments(None, None) is None
    assert store_initial_arguments(client, None) is None
    assert get_initial_arguments(client, None) is None


def test_stateless_lookup_noop():
    'Test no-op stateless lookup'

    from django_plotly_dash.util import stateless_app_lookup_hook
    lh_hook = stateless_app_lookup_hook()

    assert lh_hook is not None
    with pytest.raises(ImportError):
        lh_hook("not an app")


def test_middleware_artifacts():
    'Import and vaguely exercise middleware objects'

    from django_plotly_dash.middleware import EmbeddedHolder, ContentCollector

    eh = EmbeddedHolder()
    eh.add_css("some_css")
    eh.add_config("some_config")
    eh.add_scripts("some_scripts")

    assert eh.config == 'some_config'

    cc = ContentCollector()

    assert cc._encode("fred") == b'fred'


def test_finders():
    'Import and vaguely exercise staticfiles finders'

    from django_plotly_dash.finders import DashComponentFinder, DashAppDirectoryFinder, DashAssetFinder

    dcf = DashComponentFinder()
    dadf = DashAppDirectoryFinder()
    daf = DashAssetFinder()

    assert dcf is not None
    assert dadf is not None
    assert daf is not None


@pytest.mark.django_db
def test_app_loading(client):

    from django_plotly_dash.models import check_stateless_loaded
    from django.urls import reverse

    # Function should run wthout raising errors
    check_stateless_loaded()
    assert True

    url = reverse('the_django_plotly_dash:add_stateless_apps')

    response = client.post(url)

    # This view redirects to the main admin
    assert response.status_code == 302


@pytest.mark.django_db
def test_external_scripts_stylesheets(client):
    'Check external_stylesheets and external_scripts ends up in index'

    from demo.plotly_apps import external_scripts_stylesheets
    dash = external_scripts_stylesheets.as_dash_instance()

    with patch.object(dash, "interpolate_index") as mock:
        dash.index()

    _, kwargs = mock.call_args
    assert "https://codepen.io/chriddyp/pen/bWLwgP.css" in kwargs["css"]
    assert "https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" in kwargs["css"]
    assert "https://www.google-analytics.com/analytics.js" in kwargs["scripts"]
    assert "https://cdn.polyfill.io/v2/polyfill.min.js" in kwargs["scripts"]
    assert "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.core.js" in kwargs["scripts"]

def test_callback_decorator():
    inputs = [Input("one", "value"),
              Input("two", "value"),
              ]
    states = [Input("three", "value"),
              Input("four", "value"),
              ]

    def callback_standard(one, two, three, four):
        return

    assert DjangoDash.get_expanded_arguments(callback_standard, inputs, states) == []

    def callback_standard(one, two, three, four, extra_1):
        return

    assert DjangoDash.get_expanded_arguments(callback_standard, inputs, states) == ['extra_1']

    def callback_args(one, *args):
        return

    assert DjangoDash.get_expanded_arguments(callback_args, inputs, states) == []

    def callback_args_extra(one, *args, extra_1):
        return

    assert DjangoDash.get_expanded_arguments(callback_args_extra, inputs, states) == ['extra_1' ]

    def callback_args_extra_star(one, *, extra_1):
        return

    assert DjangoDash.get_expanded_arguments(callback_args_extra_star, inputs, states) == ['extra_1' ]


    def callback_kwargs(one, two, three, four, extra_1, **kwargs):
        return

    assert DjangoDash.get_expanded_arguments(callback_kwargs, inputs, states) == None

    def callback_kwargs(one, two, three, four, *, extra_1, **kwargs, ):
        return

    assert DjangoDash.get_expanded_arguments(callback_kwargs, inputs, states) == None