Set-Cookie header sets cookie in response but not session

When requesting a resource that responds with a `Set-Cookie` header, the `response.cookies` returns a `RequestsCookierJar` with the cookies set in the header, however, the `session.cookies` returns an empty `RequestsCookieJar`.

## Expected Result

When requesting a resource that responds with the following headers: `{'Content-Type': 'text/plain', 'set-cookie': 'foo=bar;'}`, the `response.cookies` should include the `foo=bar` cookie and the `session.cookies` should include the `foor=bar` cookie.

E.g. both should be `<RequestsCookieJar[<Cookie foo=bar for />]>`

## Actual Result

When requesting a resource that responds with the following headers: `{'Content-Type': 'text/plain', 'set-cookie': 'foo=bar;'}`, the `response.cookies` does include the `foo=bar` cookie but the `session.cookies` remains empty.

`response.cookies` yields `<RequestsCookieJar[<Cookie foo=bar for />]>`
`session.cookies` yields `<RequestsCookieJar[]>`

## Reproduction Steps

```python
import requests

session = requests.Session()
response = session.get('http://www.blah.com/')
print(response.cookies)
print(session.cookies)
```

## System Information

    $ python -m requests.help

```
{
  "chardet": {
    "version": "3.0.4"
  },
  "cryptography": {
    "version": ""
  },
  "idna": {
    "version": "2.7"
  },
  "implementation": {
    "name": "CPython",
    "version": "3.6.5"
  },
  "platform": {
    "release": "17.3.0",
    "system": "Darwin"
  },
  "pyOpenSSL": {
    "openssl_version": "",
    "version": null
  },
  "requests": {
    "version": "2.19.1"
  },
  "system_ssl": {
    "version": "100020ff"
  },
  "urllib3": {
    "version": "1.23"
  },
  "using_pyopenssl": false
}
```

Hey again @Audace, I put together a little more in depth test. Using the headers you've provided, we can still see the cookie being set on both `Session` and `Response`. We're going to need to see a few things.
* The exact headers you're being sent.
* What platform/server stack they're being generated on.
* What your `response.history` looks like.
* Output of `requests.__version__` when running your test code.

```python
import threading
import requests

from tests.testserver.server import Server, consume_socket_content

def test_session_cookies_are_set():
    def response_handler(sock):
        consume_socket_content(sock, timeout=0.5)
        sock.send(
            b'HTTP/1.1 200 OK\r\n'
            b'Content-Length: 0\r\n'
            b'Content-Type: text/plain\r\n'
            b'set-cookie: foo=bar;\r\n\r\n'
        )

    close_server = threading.Event()
    server = Server(response_handler, wait_to_close_event=close_server)

    with server as (host, port):
        url = 'http://{0}:{1}/path'.format(host, port)
        s = requests.Session()
        r = s.get(url)

        assert r.status_code == 200
        assert 'Set-Cookie' in r.headers
        assert 'foo' in s.cookies
        assert 'foo' in r.cookies
        print(s.cookies)
        print(r.cookies)
        print(requests.__version__)

        close_server.set()
```
** This is using the `tests` directory in Requests


Hi @nateprewitt,

Sure, the exact headers are the following: `{'Content-Type': 'text/plain', 'set-cookie': 'foo=bar;'}`.

The platform is MacOS High Sierra v10.13.2. 

The `response.history` yields `[]`.

The `requests.__version__` is `2.19.1`.

For clarity, this is my test code:
```python
import requests
import responses


responses.add(responses.GET, 'http://blah.com',
              json={},
              adding_headers={
                   "set-cookie": 'foo=bar;'
              })
session = requests.Session()
response = session.get('http://blah.com')
print(response.cookies)
print(session.cookies)
```

@Audace, if the server is claiming a Content-Type and doesn't specify a Transfer-Encoding or Content-Length, those are either incomplete headers, or the server isn't functioning properly.

Looking at your test code, it's not clear what is being done. I'm not familiar with `responses` as a module, and it's not clear how you're interacting with it via Requests. We will need test code that can actually be run, rather than using placeholders. Is this example actually performing network IO? My hunch here is this is likely an incomplete setup in your mocking environment which we'd want to debug on [StackOverflow](https://www.stackoverflow.com), rather than here on the issue tracker.

@nateprewitt got it. No this isn't performing network IO - it's a mocked response. I added a `Content-Length` to no avail. That being said, why would there be a difference between `response.cookies` and `session.cookies`? Is there a fundamental difference in the cookie extractor for these two jars?

@Audace it's the same process but performed in two separate places. [Here](https://github.com/requests/requests/blob/883caaf145fbe93bd0d208a6b864de9146087312/requests/sessions.py#L631-L638) for `Session` and [here](https://github.com/requests/requests/blob/883caaf145fbe93bd0d208a6b864de9146087312/requests/adapters.py#L282-L283) for `Response`.

It would appear something on your mocked response isn't populating what we're expecting in `r.raw`. As I said above, since this doesn't appear to be a defect in Requests but rather an issue in the mocking setup, we should probably move this to StackOverflow. That will avoid constantly pinging 1300 people watching the issue tracker for bugs in Requests. Feel free to ping the link here, or use the `python-requests` tag if you create a SO question. Thanks!