def test_session_fixation(self):
        """Ensure if session is empty that a new session is given."""
        user1 = create_account('user1', '[email protected]', 'Password')
        activate(user1)
        resp = self.client.post(url_for('auth.signin'), data={
            'username': 'user1',
            'password': 'Password'
        })

        session_id = None
        for header in resp.headers:
            if header[0] == 'Set-Cookie':
                session_id = parse_cookie(header[1])['session']
                rs.delete(session_id)

        resp = self.client.post(url_for('auth.signin'), data={
            'username': 'user1',
            'password': 'Password'
        })

        # Find the Set-Cookie header so we can parse it and check the session
        # identifier has been updated
        for header in resp.headers:
            if header[0] == 'Set-Cookie':
                self.assertNotEqual(session_id,
                                    parse_cookie(header[1])['session'])

    def test_cookie_quoting(self):
        val = http.dump_cookie("foo", "?foo")
        self.assert_strict_equal(val, 'foo="?foo"; Path=/')
        self.assert_strict_equal(dict(http.parse_cookie(val)), {'foo': u'?foo'})

        self.assert_strict_equal(dict(http.parse_cookie(r'foo="foo\054bar"')),
                                 {'foo': u'foo,bar'})

    def test_cookies(self):
        strict_eq(
            dict(
                http.parse_cookie(
                    "dismiss-top=6; CP=null*; PHPSESSID=0a539d42abc001cd"
                    'c762809248d4beed; a=42; b="\\";"'
                )
            ),
            {
                "CP": u"null*",
                "PHPSESSID": u"0a539d42abc001cdc762809248d4beed",
                "a": u"42",
                "dismiss-top": u"6",
                "b": u'";',
            },
        )
        rv = http.dump_cookie(
            "foo", "bar baz blub", 360, httponly=True, sync_expires=False
        )
        assert type(rv) is str
        assert set(rv.split("; ")) == {
            "HttpOnly",
            "Max-Age=360",
            "Path=/",
            'foo="bar baz blub"',
        }

        strict_eq(
            dict(http.parse_cookie("fo234{=bar; blub=Blah")),
            {"fo234{": u"bar", "blub": u"Blah"},
        )

        strict_eq(http.dump_cookie("key", "xxx/"), "key=xxx/; Path=/")
        strict_eq(http.dump_cookie("key", "xxx="), "key=xxx=; Path=/")

 def test_suggest_decorated(self):
     rv = self.app_client.get("/show_btn_decorated")
     assert parse_cookie(rv.headers["Set-Cookie"])["MAB"]
     assert "X-MAB-Debug" in rv.headers.keys()
     chosen_arm = self.get_arm(rv.headers)["color_button"]
     assert self.app.extensions['mab'].bandits["color_button"][chosen_arm]["pulls"] > 0
     assert json.loads(parse_cookie(rv.headers["Set-Cookie"])["MAB"])["color_button"] == chosen_arm

 def test_suggest_decorated(self):
     self.app.debug_headers = True
     rv = self.app_client.get("/show_btn_decorated")
     assert parse_cookie(rv.headers["Set-Cookie"])["MAB"]
     assert "X-MAB-Debug" in rv.headers.keys()
     chosen_arm = self.get_arm(rv.headers)[self.name_to_test]
     assert self.app.extensions["mab"].bandits[self.name_to_test][chosen_arm]["pulls"] > 0
     assert json.loads(parse_cookie(rv.headers["Set-Cookie"])["MAB"])[self.name_to_test] == chosen_arm

 def test_cookies(self):
     self.assert_strict_equal(
         dict(http.parse_cookie("dismiss-top=6; CP=null*; PHPSESSID=0a539d42abc001cd" "c762809248d4beed; a=42")),
         {u"CP": u"null*", u"PHPSESSID": u"0a539d42abc001cdc762809248d4beed", u"a": u"42", u"dismiss-top": u"6"},
     )
     self.assert_strict_equal(
         set(http.dump_cookie("foo", "bar baz blub", 360, httponly=True, sync_expires=False).split(u"; ")),
         set([u"HttpOnly", u"Max-Age=360", u"Path=/", u'foo="bar baz blub"']),
     )
     self.assert_strict_equal(dict(http.parse_cookie("fo234{=bar blub=Blah")), {u"blub": u"Blah"})

 def test_cookies(self):
     assert http.parse_cookie('dismiss-top=6; CP=null*; PHPSESSID=0a539d42abc001cd'
                         'c762809248d4beed; a=42') == {
         'CP':           u'null*',
         'PHPSESSID':    u'0a539d42abc001cdc762809248d4beed',
         'a':            u'42',
         'dismiss-top':  u'6'
     }
     assert set(http.dump_cookie('foo', 'bar baz blub', 360, httponly=True,
                            sync_expires=False).split('; ')) == \
            set(['HttpOnly', 'Max-Age=360', 'Path=/', 'foo="bar baz blub"'])
     assert http.parse_cookie('fo234{=bar blub=Blah') == {'blub': 'Blah'}

        def injecting_start_response(status, headers, exc_info=None):
            # Iterate through the headers looking for Set-Cookie
            updates = False
            for idx, (header, value)  in enumerate(headers):
                if header == 'Set-Cookie':
                    cookie = parse_cookie(value)
                    if 'zappa' in cookie:
                        # We found a header in the response object that sets
                        # zappa as a cookie. Delete it.
                        del(headers[idx])
                        del(cookie['zappa'])
                        print 'deleted zappa set-cooke header'
                        print 'remaining cookie', cookie
                    if cookie:
                        updates = True
                        request_cookies.update(cookie)
                        print 'setting cookie', cookie

            # Encode cookies into Zappa cookie
            if updates and request_cookies:
                final_cookies = ["{cookie}={value}".format(cookie=k, value=v) for k, v in request_cookies.items()]
                encoded = base58.b58encode(';'.join(final_cookies))
                headers.append(('Set-Cookie', dump_cookie('zappa', value=encoded)))

            return start_response(status, headers, exc_info)

 def test_pull_is_called(self):
     self.bandit_a.pull_arm = Mock()
     self.bandit_b.pull_arm = Mock()
     req = self.app_client.get('/show_btn_decorated')
     chosen_arms = json.loads(parse_cookie(req.headers["Set-Cookie"])["MAB"])
     self.bandit_a.pull_arm.assert_called_with(chosen_arms['color_button'])
     self.bandit_b.pull_arm.assert_called_with(chosen_arms['color_bg'])

 def getCookie(self, response, cookie_name):
     cookies = response.headers.getlist('Set-Cookie')
     for cookie in cookies:
         value = parse_cookie(cookie).get(cookie_name)
         if value:
             return value
     return None

 def get_cookie(self, name):
     cookies = self.rsp.headers.getlist('Set-Cookie')
     for cookie in cookies:
         c_key, c_value = parse_cookie(cookie).items()[0]
         if c_key == name:
             return c_value
     return None

 def _get_session(self, environ):
     cookie = parse_cookie(environ.get('HTTP_COOKIE', ''))
     id = cookie.get(self.configuration['cookie']['name'], None)
     if id is not None:
         return self.store.get(id)
     else:
         return self.store.new()

 def test_from_cookie(self):
     print self.name_to_test
     first_req = self.app_client.get("/show_btn_decorated")
     assert "X-MAB-Debug" in first_req.headers.keys()
     chosen_arm = json.loads(parse_cookie(first_req.headers["Set-Cookie"])["MAB"])[self.name_to_test]
     self.app_client.get("/reward_decorated")
     assert self.app.extensions['mab'].bandits[self.name_to_test][chosen_arm]["reward"] > 0

 def get_session(self, resp):
   '''
   get the value of the Set-Cookie header, load the value as JSON since that's
   what we're working with for test purposes
   '''
   cookies = parse_cookie(resp.headers.get('Set-Cookie'))
   return loads(cookies.get(session_cookie_name))

 def test_empty_keys_are_ignored(self):
     strict_eq(
         dict(
             http.parse_cookie("first=IamTheFirst ; a=1; a=2 ;second=andMeTwo; ; ")
         ),
         {"first": u"IamTheFirst", "a": u"2", "second": u"andMeTwo"},
     )

 def getCookie(self, response, cookie_name):
     cookies = response.headers.getlist('Set-Cookie')
     for cookie in cookies:
         key, value = list(parse_cookie(cookie).items())[0]
         if key == cookie_name:
             return value
     return None

 def test_aguid_cookie_domain(self):
     for host in [('http://localhost', '.localhost'),
                  ('http://track.my.jobs', '.my.jobs'),
                  ('http://this.is.a.long.host.com', '.host.com')]:
         response = self.client.get('/pixel.gif',
                                    base_url=host[0])
         domain = parse_cookie(response.headers['Set-Cookie'])['Domain']
         self.assertEqual(domain, host[1])

    def test_cookie_unicode_dumping(self):
        val = http.dump_cookie('foo', u'\N{SNOWMAN}')
        h = datastructures.Headers()
        h.add('Set-Cookie', val)
        self.assert_equal(h['Set-Cookie'], 'foo="\\342\\230\\203"; Path=/')

        cookies = http.parse_cookie(h['Set-Cookie'])
        self.assert_equal(cookies['foo'], u'\N{SNOWMAN}')

    def test_cookie_unicode_dumping(self):
        val = http.dump_cookie("foo", u"\N{SNOWMAN}")
        h = datastructures.Headers()
        h.add("Set-Cookie", val)
        assert h["Set-Cookie"] == 'foo="\\342\\230\\203"; Path=/'

        cookies = http.parse_cookie(h["Set-Cookie"])
        assert cookies["foo"] == u"\N{SNOWMAN}"

 def is_trusted(self, environ):
     """Checks if the request passed the pin test."""
     if self.pin is None:
         return True
     ts = parse_cookie(environ).get(self.pin_cookie_name, type=int)
     if ts is None:
         return False
     return (time.time() - PIN_TIME) < ts