def test_session_get():
    responses.add(
        responses.GET,
        'http://foo.bar.baz/api/v1.0/test',
        body='okay',
        status=200)
    host = 'foo.bar.baz'
    token = '5f1e08b6-38ec-4a99-9d0f-00d29c4e325b'
    marker = '40c3eaf6-6a8a-11e7-a4bd-080027ef795a'

    def auth_gen():
        return [('X-Auth-Token', token)]

    dd_ses = dc_session.DrydockSession(host, auth_gen=auth_gen, marker=marker)

    resp = dd_ses.get('v1.0/test')
    req = resp.request

    assert req.headers.get('X-Auth-Token', None) == token
    assert req.headers.get('X-Context-Marker', None) == marker 

def test_session_get_returns_401(*args):
    responses.add(
        responses.GET,
        'http://foo.bar.baz/api/v1.0/test',
        body='okay',
        status=401)
    host = 'foo.bar.baz'
    token = '5f1e08b6-38ec-4a99-9d0f-00d29c4e325b'
    marker = '40c3eaf6-6a8a-11e7-a4bd-080027ef795a'

    def auth_gen():
        return [('X-Auth-Token', dc_session.KeystoneClient.get_token())]

    dd_ses = dc_session.DrydockSession(host, auth_gen=auth_gen, marker=marker)

    resp = dd_ses.get('v1.0/test')
    req = resp.request

    assert req.headers.get('X-Auth-Token', None) == token
    assert req.headers.get('X-Context-Marker', None) == marker
    assert dc_session.KeystoneClient.get_token.call_count == 2 

def test_client_get_nodes_for_filter_post():
    node_list = ['node1', 'node2']

    host = 'foo.bar.baz'

    responses.add(
        responses.POST,
        "http://%s/api/v1.0/nodefilter" % (host),
        json=node_list,
        status=200)

    dd_ses = dc_session.DrydockSession(host)
    dd_client = dc_client.DrydockClient(dd_ses)

    design_ref = {'ref': 'hello'}
    validation_resp = dd_client.get_nodes_for_filter(design_ref)

    assert 'node1' in validation_resp
    assert 'node2' in validation_resp 

def test_client_validate_design_post():
    validation = {'status': 'success'}

    host = 'foo.bar.baz'

    responses.add(
        responses.POST,
        "http://%s/api/v1.0/validatedesign" % (host),
        json=validation,
        status=200)

    dd_ses = dc_session.DrydockSession(host)
    dd_client = dc_client.DrydockClient(dd_ses)

    validation_resp = dd_client.validate_design('href-placeholder')

    assert validation_resp['status'] == validation['status'] 

def test_post(patch1, patch2):
    """
    Test post functionality
    """
    responses.add(
        responses.POST,
        'http://promhost:80/api/v1.0/node-label/n1',
        body='{"key1":"label1"}',
        status=200)

    prom_session = PromenadeSession()
    result = prom_session.post(
        'v1.0/node-label/n1', body='{"key1":"label1"}', timeout=(60, 60))

    assert PROM_HOST == prom_session.host
    assert result.status_code == 200 

def test_relabel_node(patch1, patch2):
    """
    Test relabel node call from Promenade
    Client
    """
    responses.add(
        responses.PUT,
        'http://promhost:80/api/v1.0/node-labels/n1',
        body='{"key1":"label1"}',
        status=200)

    prom_client = PromenadeClient()

    result = prom_client.relabel_node('n1', {"key1": "label1"})

    assert result == {"key1": "label1"} 

def test_parse_authentication_response_preserves_id_token_jwt(self):
        facade = PyoidcFacade(ProviderConfiguration(provider_metadata=self.PROVIDER_METADATA,
                                                    client_metadata=self.CLIENT_METADATA),
                              self.REDIRECT_URI)
        state = 'state-1234'
        now = int(time.time())
        id_token, id_token_signing_key = signed_id_token({
            'iss': self.PROVIDER_METADATA['issuer'],
            'sub': 'test_sub',
            'aud': 'client1',
            'exp': now + 1,
            'iat': now
        })
        responses.add(responses.GET,
                      self.PROVIDER_METADATA['jwks_uri'],
                      json={'keys': [id_token_signing_key.serialize()]})
        auth_response = AuthorizationResponse(**{'state': state, 'id_token': id_token})
        parsed_auth_response = facade.parse_authentication_response(auth_response)
        assert isinstance(parsed_auth_response, AuthorizationResponse)
        assert parsed_auth_response['state'] == state
        assert parsed_auth_response['id_token_jwt'] == id_token 

def test_should_fetch_provider_metadata_if_not_given(self):
        provider_metadata = {
            'issuer': self.PROVIDER_BASEURL,
            'authorization_endpoint': self.PROVIDER_BASEURL + '/auth',
            'jwks_uri': self.PROVIDER_BASEURL + '/jwks'
        }
        responses.add(responses.GET,
                      self.PROVIDER_BASEURL + '/.well-known/openid-configuration',
                      json=provider_metadata)

        provider_config = ProviderConfiguration(issuer=self.PROVIDER_BASEURL,
                                                client_registration_info=ClientRegistrationInfo())
        provider_config.ensure_provider_metadata()
        assert provider_config._provider_metadata['issuer'] == self.PROVIDER_BASEURL
        assert provider_config._provider_metadata['authorization_endpoint'] == self.PROVIDER_BASEURL + '/auth'
        assert provider_config._provider_metadata['jwks_uri'] == self.PROVIDER_BASEURL + '/jwks' 

def test_should_register_dynamic_client_if_client_registration_info_is_given(self):
        registration_endpoint = self.PROVIDER_BASEURL + '/register'
        responses.add(responses.POST, registration_endpoint, json={'client_id': 'client1', 'client_secret': 'secret1'})

        provider_config = ProviderConfiguration(
            provider_metadata=self.provider_metadata(registration_endpoint=registration_endpoint),
            client_registration_info=ClientRegistrationInfo())

        extra_args = {'extra_args': 'should be passed'}
        redirect_uris = ['https://client.example.com/redirect']
        provider_config.register_client(redirect_uris, extra_args)
        assert provider_config._client_metadata['client_id'] == 'client1'
        assert provider_config._client_metadata['client_secret'] == 'secret1'
        assert provider_config._client_metadata['redirect_uris'] == redirect_uris

        expected_registration_request = {'redirect_uris': redirect_uris}
        expected_registration_request.update(extra_args)
        assert json.loads(responses.calls[0].request.body.decode('utf-8')) == expected_registration_request 

def test_token_error_response_calls_to_error_view_if_set(self):
        token_endpoint = self.PROVIDER_BASEURL + '/token'
        error_response = {'error': 'invalid_request', 'error_description': 'test error'}
        responses.add(responses.POST, token_endpoint, json=error_response)

        authn = self.init_app(provider_metadata_extras={'token_endpoint': token_endpoint})
        error_view_mock = self.get_view_mock()
        authn.error_view(error_view_mock)
        state = 'test_tate'
        with self.app.test_request_context('/redirect_uri?code=foo&state={}'.format(state)):
            UserSession(flask.session, self.PROVIDER_NAME)
            flask.session['state'] = state
            flask.session['nonce'] = 'test_nonce'
            result = authn._handle_authentication_response()

        self.assert_view_mock(error_view_mock, result)
        error_view_mock.assert_called_with(**error_response) 

def test_interest_form_post_triggers_slack_notification(self, testapp):
        ''' A valid interest form post triggers a Slack notification.
        '''

        # set a fake Slack webhook URL
        fake_webhook_url = 'http://webhook.example.com/'
        current_app.config['SLACK_WEBHOOK_URL'] = fake_webhook_url

        # create a mock to receive POST requests to that URL
        responses.add(responses.POST, fake_webhook_url, status=200)

        # post an interest form submission
        testapp.post("/interest/", params=dict(name="Jean Weaver", agency="Clinton Police Department", location="Clinton, OK", phone="580-970-3338", email="jean.weaver@example.com", comments="I'm interested in Comport as an open-source tool!"))

        # test the captured post payload
        post_body = json.loads(responses.calls[0].request.body)
        assert 'New Interest Form Submission!' in post_body['text']

        # delete the fake Slack webhook URL
        del(current_app.config['SLACK_WEBHOOK_URL'])
        # reset the mock
        responses.reset() 

def test_invalid_confidentials_should_raise():
    responses.add(
        responses.POST,
        "https://api.twitter.com/oauth2/token",
        json={
            "errors": [
                {
                    "code": 99,
                    "message": "Unable to verify your credentials",
                    "label": "authenticity_token_error",
                }
            ]
        },
        status=403,
    )

    with pytest.raises(e.BearerTokenNotFetchedError):
        _ = twt_img.Downloader("my api key", "my api secret") 

def setUp(self):
        self.client = self.app.test_client()
        self.app_context = self.app.app_context()
        self.app_context.push()
        for table in reversed(self.db.metadata.sorted_tables):
            self.db.session.execute(table.delete())
        # Mock responses from haveibeenpwned.
        responses.add(
            responses.GET,
            re.compile(
                r"^(https:\/\/api\.pwnedpasswords\.com\/range\/836BA).*"),
            body=("BDDC66080E01D52B8272AA9461C69EE0496:12145\n"
                  "00d4f6e8fa6eecad2a3aa415eec418d38ec:2"))
        responses.add(
            responses.GET,
            re.compile(
                r"^(https:\/\/api\.pwnedpasswords\.com\/)(?!.*836BA).*"),
            body=("BDDC66080E01D52B8272AA9461C69EE0496:12145\n"
                  "00d4f6e8fa6eecad2a3aa415eec418d38ec:2")) 

def test_api_post_haveibeenpwned_not_reachable(self):
        payload = {
            "secret": "secret message",
            "passphrase": "Hello123",
            "haveibeenpwned": True
        }
        with self.client as c:
            with responses.RequestsMock() as rsps:
                rsps.add(
                    responses.GET,
                    re.compile(r"^(https:\/\/api\.pwnedpasswords\.com\/).*"),
                    body=Exception)
                response = json.loads(
                    c.post("/api/c", json=payload).get_data())

        # haveibeenpwned wasn't reachable, but secret still created if it has
        # all mandatory requirements.
        r = Parse(response)
        self.assertEqual(r.response.status, "created") 

def test_extract_link(self):
        success_response = {'success': True, 'data': 'link'}
        responses.add(responses.POST, constants.ENDPOINTS['extract_link'],
                      json=success_response,
                      status=200)
        responses.add(responses.POST, constants.ENDPOINTS['extract_link'],
                      status=401)
        # success call
        result = utils.extract_link(self.session, 'https://www.ojbk.com')
        self.assertEqual(result, 'link')
        self.assertEqual(len(responses.calls), 1)
        self.assertEqual(responses.calls[0].request.url, constants.ENDPOINTS['extract_link'])
        self.assertEqual(responses.calls[0].response.json(), success_response)
        # failed call
        with self.assertRaises(requests.HTTPError) as cm:
            utils.extract_link(self.session, 'https://www.ojbk.com')
        self.assertEqual(len(responses.calls), 2)
        self.assertEqual(cm.exception.response.status_code, 401) 

def test_get_uptoken(self):
        params = {'bucket': 'jike'}
        success_reponse = {'uptoken': 'token'}
        responses.add(responses.GET, constants.ENDPOINTS['picture_uptoken'],
                      json=success_reponse, status=200)
        responses.add(responses.GET, constants.ENDPOINTS['picture_uptoken'],
                      status=404)
        # success call
        result = utils.get_uptoken()
        self.assertEqual(result, 'token')
        self.assertEqual(len(responses.calls), 1)
        self.assertEqual(responses.calls[0].request.url,
                         constants.ENDPOINTS['picture_uptoken'] + '?' + urlencode(params))
        self.assertEqual(responses.calls[0].response.json(), success_reponse)
        # failed call
        with self.assertRaises(requests.HTTPError) as cm:
            utils.get_uptoken()
        self.assertEqual(len(responses.calls), 2)
        self.assertEqual(cm.exception.response.status_code, 404) 

def test_address(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_address-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_address-10-getaddress.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_address-10-getaddress.json'),
            status=200)
        self.wallet = Wallet(JSONRPCWallet())
        waddr = self.wallet.address()
        a0addr = self.wallet.accounts[0].address()
        self.assertEqual(len(responses.calls), 3)
        self.assertEqual(waddr, a0addr)
        self.assertIsInstance(waddr, Address)
        self.assertEqual(
            waddr,
            '596ETuuDVZSNox73YLctrHaAv72fBboxy3atbEMnP3QtdnGFS9KWuHYGuy831SKWLUVCgrRfWLCxuCZ2fbVGh14X7mFrefy')
        self.assertEqual(waddr.label, 'Primary account')
        self.assertEqual(a0addr.label, 'Primary account') 

def test_account_creation(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_account_creation-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_account_creation-10-create_account.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_account_creation-20-getbalance.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_account_creation-30-get_accounts.json'),
            status=200)
        w = Wallet(JSONRPCWallet())
        self.assertEqual(1, len(w.accounts))
        w.new_account('account 1')
        self.assertEqual(2, len(w.accounts))
        self.assertEqual('account 1', w.accounts[1].label)
        self.assertEqual(0, w.accounts[1].balance())
        acc0, acc1 = w.accounts
        w.refresh()
        self.assertEqual(2, len(w.accounts))
        self.assertEqual('account 1', w.accounts[1].label)
        self.assertEqual([acc0, acc1], w.accounts) 

def test_new_address(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_new_address-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_new_address-10-new_address_account_0.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_new_address-20-new_address_account_1.json'),
            status=200)
        w = Wallet(JSONRPCWallet())
        subaddr, index = w.new_address()
        self.assertIsInstance(subaddr, SubAddress)
        self.assertIsInstance(index, int)
        subaddr, index = w.accounts[1].new_address()
        self.assertIsInstance(subaddr, SubAddress)
        self.assertIsInstance(index, int) 

def test_incoming_by_tx_id__multiple_ids(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-7ab84-get_transfer_by_txid.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-55e75-get_transfer_by_txid.json'),
            status=200)
        self.wallet = Wallet(JSONRPCWallet())
        pmts = self.wallet.incoming(tx_id=[
            '7ab84fe2fb34467c590cde2f7d6ba7de5928a2db6c84c6ccfff8962eca0ad99c',
            '55e758d7d259bb316551ddcdd4808711de99c30b8b5c52de3e95e563fd92d156'])
        self.assertEqual(len(pmts), 4)
        self.assertEqual(pmts[0].amount, Decimal(4))
        self.assertEqual(pmts[1].amount, Decimal(1))
        self.assertEqual(pmts[2].amount, Decimal(1))
        self.assertEqual(pmts[3].amount, Decimal(2)) 

def test_incoming_by_tx_id__mempool(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-31b52-get_transfer_by_txid.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-31b52-get_transfer_by_txid.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_incoming_by_tx_id-31b52-get_transfer_by_txid.json'),
            status=200)
        self.wallet = Wallet(JSONRPCWallet())
        pmts = self.wallet.incoming(
            tx_id='31b527fb9c27e759d56892fef93136df1057186c5cf4e3c93c5298b70160f562')
        self.assertEqual(len(pmts), 0)
        pmts = self.wallet.incoming(
            tx_id='31b527fb9c27e759d56892fef93136df1057186c5cf4e3c93c5298b70160f562',
            unconfirmed=True)
        self.assertEqual(len(pmts), 1)
        pmts = self.wallet.incoming(
            tx_id='31b527fb9c27e759d56892fef93136df1057186c5cf4e3c93c5298b70160f562',
            confirmed=False)
        self.assertEqual(len(pmts), 0) 

def test_outgoing_by_tx_id__mempool(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_outgoing_by_tx_id-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_outgoing_by_tx_id-afaf0-get_transfer_by_txid.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_outgoing_by_tx_id-afaf0-get_transfer_by_txid.json'),
            status=200)
        self.wallet = Wallet(JSONRPCWallet())
        acc = self.wallet.accounts[1]
        pmts = acc.outgoing(tx_id='afaf04e5e40c6b60fc7cc928a88843fc96031ec2b567c310ee61abf3d00020da')
        self.assertEqual(len(pmts), 0)
        pmts = acc.outgoing(
            tx_id='afaf04e5e40c6b60fc7cc928a88843fc96031ec2b567c310ee61abf3d00020da',
            unconfirmed=True)
        self.assertEqual(len(pmts), 1) 

def test_sweep_all(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_sweep_all-00-get_accounts.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_sweep_all-10-getbalance.json'),
            status=200)
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read('test_sweep_all-20-sweep_all.json'),
            status=200)
        w = Wallet(JSONRPCWallet())
        result = w.sweep_all(
            '55LTR8KniP4LQGJSPtbYDacR7dz8RBFnsfAKMaMuwUNYX6aQbBcovzDPyrQF9KXF9tVU6Xk3K8no1BywnJX6GvZX8yJsXvt',
            relay=False)
        self.assertEqual(len(result), 1)
        result = result[0]
        self.assertIsInstance(result[0], Transaction)
        self.assertEqual(Decimal('111.086545699972'), result[1]) 

def test_block(self):
        responses.add(responses.POST, self.jsonrpc_url,
            json=self._read("test_block-423cd4d170c53729cf25b4243ea576d1e901d86e26c06d6a7f79815f3fcb9a89.json"),
            status=200)
        responses.add(responses.POST, self.transactions_url,
            json=self._read("test_block-423cd4d170c53729cf25b4243ea576d1e901d86e26c06d6a7f79815f3fcb9a89-txns.json"),
            status=200)
        blk = self.daemon.block("423cd4d170c53729cf25b4243ea576d1e901d86e26c06d6a7f79815f3fcb9a89")
        self.assertEqual(
            blk.hash,
            "423cd4d170c53729cf25b4243ea576d1e901d86e26c06d6a7f79815f3fcb9a89")
        self.assertEqual(blk.height, 451992)
        self.assertIsInstance(blk.reward, decimal.Decimal)

        self.assertIn("24fb42f9f324082658524b29b4cf946a9f5fcfa82194070e2f17c1875e15d5d0", blk)
        for tx in blk.transactions:
            self.assertIn(tx, blk)

        # tx not in block
        self.assertNotIn("e3a3b8361777c8f4f1fd423b86655b5c775de0230b44aa5b82f506135a96c53a", blk)
        # wrong arg type
        self.assertRaises(ValueError, lambda txid: txid in blk, 1245) 

def test_request_made(self):
        responses.add(responses.GET, 'https://example.com', status=200)

        donation = Donation.objects.create(
            timereceived=datetime.datetime(2018, 1, 1),
            comment='',
            amount=Decimal(1.5),
            domain='PAYPAL',
            donor=self.donor,
            event=self.event,
        )

        eventutil.post_donation_to_postbacks(donation)

        assert len(responses.calls) == 1
        assert (
            responses.calls[0].request.url
            == 'https://example.com/?comment=&amount=1.5&timereceived=2018-01-01+00%3A00%3A00&donor__visibility=FIRST&domain=PAYPAL&id=1&donor__visiblename=%28No+Name%29'
        )
        assert responses.calls[0].response.status_code == 200 

def test_fetch_tfdv_whl_bad_response():
        test_wheel = {"I": "is-a-wheel"}
        responses.add(responses.GET,
                      "https://files.pythonhosted.org/packages/f0/f1"
                      "/c3441933b8a5fe0737dab7850804c7cec3f5fe7b2cc609dd1ce5987df768"
                      "/tensorflow_data_validation-0.11.0-cp27-cp27mu-manylinux1_x86_64.whl",
                      status=200, json=test_wheel)

        responses.add(responses.GET, "https://pypi.org/simple/tensorflow_data_validation",
                      status=200, body="""
<!DOCTYPE html>
<html>
... garbled response ...
unparseable
""")

        try:
            fetch_tfdv_whl("0.11.0")
            assert False
        except Exception as e:
            assert "Problem fetching package. Couldn't parse listing" in str(e) 

def test_saved_variants_page(self):
        url = reverse(saved_variants_page, args=['Tier 1 - Novel gene and phenotype'])
        self.check_staff_login(url)

        response = self.client.get(url)
        self.assertEqual(response.status_code, 400)
        self.assertEqual(response.json()['message'], 'Select a gene to filter variants')

        response = self.client.get('{}?gene=ENSG00000135953'.format(url))
        self.assertEqual(response.status_code, 200)
        response_json = response.json()
        self.assertSetEqual(set(response_json.keys()), {
            'projectsByGuid', 'locusListsByGuid', 'savedVariantsByGuid', 'variantFunctionalDataByGuid', 'genesById',
            'variantNotesByGuid', 'individualsByGuid', 'variantTagsByGuid', 'familiesByGuid'})
        expected_variant_guids = {
            'SV0000001_2103343353_r0390_100', 'SV0000007_prefix_19107_DEL_r00', 'SV0000006_1248367227_r0003_tes'}
        self.assertSetEqual(set(response_json['savedVariantsByGuid'].keys()), expected_variant_guids)

        all_tag_url = reverse(saved_variants_page, args=['ALL'])
        response = self.client.get('{}?gene=ENSG00000135953'.format(all_tag_url))
        self.assertEqual(response.status_code, 200)
        expected_variant_guids.add('SV0000002_1248367227_r0390_100')
        self.assertSetEqual(set(response.json()['savedVariantsByGuid'].keys()), expected_variant_guids) 

def test_list_policies(nomad_setup):
    responses.add(
        responses.GET,
        "http://{ip}:{port}/v1/sentinel/policies".format(ip=common.IP, port=common.NOMAD_PORT),
        status=200,
        json=[
            {
                "Name": "foo",
                "Description": "test policy",
                "Scope": "submit-job",
                "EnforcementLevel": "advisory",
                "Hash": "CIs8aNX5OfFvo4D7ihWcQSexEJpHp+Za+dHSncVx5+8=",
                "CreateIndex": 8,
                "ModifyIndex": 8
            }
        ]
    )

    policies = nomad_setup.sentinel.get_policies()
    assert isinstance(policies, list)
    assert "foo" in nomad_setup.sentinel.get_policies()[0]["Name"] 

def test_get_policy(nomad_setup):
    responses.add(
        responses.GET,
        "http://{ip}:{port}/v1/sentinel/policy/foo".format(ip=common.IP, port=common.NOMAD_PORT),
        status=200,
        json={
            "Name": "foo",
            "Description": "test policy",
            "Scope": "submit-job",
            "EnforcementLevel": "advisory",
            "Policy": "main = rule { true }\n",
            "Hash": "CIs8aNX5OfFvo4D7ihWcQSexEJpHp+Za+dHSncVx5+8=",
            "CreateIndex": 8,
            "ModifyIndex": 8
        }
    )

    policy = nomad_setup.sentinel.get_policy("foo")
    assert "advisory" in policy["EnforcementLevel"] 

def test_client_task_get():
    task = {
        'action': 'deploy_node',
        'result': 'success',
        'parent_task': '444a1a40-7b5b-4b80-8265-cadbb783fa82',
        'subtasks': [],
        'status': 'complete',
        'result_detail': {
            'detail': ['Node cab23-r720-17 deployed']
        },
        'site_name': 'mec_demo',
        'task_id': '1476902c-758b-49c0-b618-79ff3fd15166',
        'node_list': ['cab23-r720-17'],
        'design_id': 'fcf37ba1-4cde-48e5-a713-57439fc6e526'
    }

    host = 'foo.bar.baz'

    responses.add(
        responses.GET,
        "http://%s/api/v1.0/tasks/1476902c-758b-49c0-b618-79ff3fd15166" %
        (host),
        json=task,
        status=200)

    dd_ses = dc_session.DrydockSession(host)
    dd_client = dc_client.DrydockClient(dd_ses)

    task_resp = dd_client.get_task('1476902c-758b-49c0-b618-79ff3fd15166')

    assert task_resp['status'] == task['status']