#!/usr/bin/env python3

import logging

logging.basicConfig(
    level=logging.DEBUG,
    filename='foo.log',
    format='%(asctime)s:%(levelname)s:%(module)s:%(message)s',
)

def main():
    pass

if __name__ == "__main__":
    main()

import logging
_logger = logging.getLogger(__name__)
_logger.error("foo", exc_info=True)
_logger.exception("foo", exc_info=True)

from oneview.tests.graphql import AdminUserMixin, GraphqlTestCase
from oneview.tests.model_mocks import TodoFactory

class TestFoo(AdminUserMixin, GraphqlTestCase):
    def test_bar(self):
        query = """
            mutation query(
                $todoTodo: ID!,
            ) {
                todoTodo(
                    todoTodo: $todoTodo,
                    todoTodo: $todoTodo,
                ) {
                    ok
                    errors
                }
            }
        """

        variables = {
            "todoTodo": "todo",
        }

        response = self.schema.execute(
            query,
            variables=variables,
            context_value=self.admin_context,
        )

        self.assertIsNone(response.errors)
        self.assertTrue(response.data["fooBar"]["ok"])

from django.test import TestCase

class TestFoo(TestCase):
    def test_foo(self):
        pass

for a, b in (("foo", "bar"), ("baz", "bazz")):
    with self.subTest(a=a, b=b):
        self.assertEqual(...)

    @classmethod
    def setUpTestData(cls):
        pass

with self.assertLogs("foo.foo.foo", level="INFO") as logger_context_manager:
    # TODO
    pass

self.assertEqual(
    logger_context_manager.output,
    [
        "INFO:foo.foo.foo:logger message"
    ]
)

# if using _logger.error('foo', exc_info=True)
# test like this
self.assertIn(
    "ERROR:foo.foo.foo.foo:Foo",
    logger_context_manager.output[0],
)

with self.assertRaisesMessage(ValueError, "invalid literal for int()"):
    pass

with self.assertRaises(ValueError):
    pass

from freezegun import freeze_time
import pytz

with freeze_time("2000-01-01T00:00:00", tz_offset=0):
    # TODO: call some function
    pass

self.assertEqual(foo, datetime(2000, 1, 1, 0, 0, 0, tzinfo=pytz.UTC))

from django.test import override_settings

@override_settings(ENABLE_TRUSTS=True)
def test_foo(self):
    pass

json_response = json.dumps(
    {
        "url": "https://fake_bucket_name.aws.com/fake_file_key",
        "id": expected_document_client_portal_id,
    }
)
mock_response = Response()
mock_response.status_code = 200
mock_response._content = bytes(json_response, encoding="utf-8")

mock_requests.post.return_value = mock_response

mock_response = mock.Mock()
mock_response.raise_for_status.side_effect = HTTPError("Foo")

mock_requests.post.return_value = mock_response

self.assertEqual(
    mock_submit_entity.call_args_list,
    [
        call(entity=pot, data=pot.to_curo(), info=mock.ANY),
        call(entity=task, data=task.to_curo(), info=mock.ANY),
    ],
)

oneview.errors.OneViewCuroCodeDoesNotExistError: Curo code does not exist. CuroCode.get is called with args: (), kwargs: {'entity': 't4a_review', 'field': 'review_reason', 'value': 'Initial client meeting'}

CuroCode.objects.create(
    entity='t4a_review',
    field='review_reason',
    value='Initial client meeting',
)

try:
    response = requests.post(url, headers=headers, data=json.dumps(data))
    response.raise_for_status()
except HTTPError as error:
    _logger.exception(error)
    return FooBar(
        errors=[f"foo bar"],
        ok=False,
    )

from requests import RequestException
try:
    r = requests.get(url,timeout=3)
    r.raise_for_status()
except RequestException as error:
    _logger.exception(error)