Cookies never returned in response object

I have been trying to get the cookies from a response, as your docs suggest (http://docs.python-requests.org/en/master/user/quickstart/#cookies [first example]), but it does not seem to be working.

When I dug through the `sessions.py` (https://github.com/kennethreitz/requests/blob/master/requests/sessions.py#L655), it looks like cookies are extracted to the cookie jar on the `Session` object, but never set on the response.

I had to do the following to get my intended behavior (which is probably not entirely correct, since it will copy all cookies on the `Session`, not just the ones from the most recent request):
```
>>> url = 'http://example.com/some/cookie/setting/url'
>>> s = requests.Session()
>>> r = s.get(url)
>>> r.cookies = s.cookies

>>> r.cookies['example_cookie_name']
'example_cookie_value'
```

Hey @dubhunter, I'm actually unable to reproduce this in either Python 2 or 3 for Requests 2.13.0.

Could you please provide the version of Requests you're using and verify for me that the script below returns `<RequestsCookieJar[]>`? No need to provide the contents if the RequestsCookieJar is populated.

```python
import requests

s = requests.Session()
resp = s.get('https://github.com/kennethreitz/requests')
print(resp.cookies)
```

Edit: As an after thought, is your response being redirected? `r.history` will provide the redirect chain of your final response object. If the cookies are set on a redirect response, they'll live on that object, rather than the final object you're receiving.

@nateprewitt You are correct. After further digging, it looks like I am having trouble because the `CookiePolicy` set on the `Session` object is not copied to `Response` and there is no way to set the `CookiePolicy` for the `Response`.

We can close this issue and open another, or reword this one.

Thoughts?

I was able to work around this with the following code in my adapter:
```
def build_response(self, req, resp):
    response = super().build_response(req, resp)
    response.cookies = cookiejar_from_dict({})
    response.cookies.set_policy(self.cookie_policy)
    extract_cookies_to_jar(response.cookies, req, resp)
    return response

@property
def cookie_policy(self):
    return CookiePolicy()
```

I think the cookie policy concern is fundamentally part of #3669. However, you may find a better workaround is to patch `requests.cookies.requests_cookie_policy` to return whatever it is you want. That function is used to initialize all `RequestsCookieJar` objects.

It seems like this may be more closely related to #3416 and #3463. @dubhunter, would you mind clarifying a bit further your desired use case/behaviour here? It seems like you want a `Response` specific cookie policy propagated by the Session?

#3416 was asking for the user to be able to persist a Session-wide policy that would scope what cookies were allowed into the Session CookieJar. While this would still allow the user to inspect ALL cookies returned on an individual response, it would only carry policy-approved cookies to the next request, which still seems reasonable to me. Is this anywhere inline with your use case?

Yes, #3416 seems to cover my use case. It would also be nice to be able to override `RequestsCookieJar` (since the cookie policy is never consulted when sending cookies), but that has lower utility.

@Lukasa @sigmavirus24, do either of you have any further thoughts on persisting cookie policies? I'm still not ecstatic about the implementation in #3463 but it seems a step in the right direction for cases like this. I only ask since #3998 will make doing this more difficult.

Either way we can probably close this out as a dupe of #3416.

Ok, let's close this as a dupe. I think persisting cookie policies would solve the problem in #3998, so I'm open to just preferring doing that.