Path 1: 281 calls (0.81)

→ app Flask (281)

→ session SecureCookieSession (281)

→ response Response (281)

↩ return None (281)

10 run 23 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 2: 41 calls (0.12)

→ app Flask (39) test_session_dynamic_cookie_name..CustomFlask (2)

→ session SecureCookieSession (41)

→ response Response (41)

22 run 11 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 3: 13 calls (0.04)

→ app Flask (11) test_session_dynamic_cookie_name..CustomFlask (2)

→ session SecureCookieSession (13)

→ response Response (13)

↩ return None (13)

11 run 22 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 4: 6 calls (0.02)

→ app Flask (6)

→ session SecureCookieSession (6)

→ response Response (6)

↩ return None (6)

19 run 14 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 5: 2 calls (0.01)

→ app Flask (2)

→ session SecureCookieSession (2)

→ response Response (2)

↩ return None (2)

10 run 23 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 6: 1 calls (0.0)

→ app Flask (1)

→ session SecureCookieSession (1)

→ response Response (1)

⚠ exception ValueError (1)

21 run 12 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 7: 1 calls (0.0)

→ app Flask (1)

→ session SecureCookieSession (1)

→ response Response (1)

21 run 12 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")
            

Path 8: 1 calls (0.0)

→ app Flask (1)

→ session SecureCookieSession (1)

→ response Response (1)

↩ return None (1)

11 run 22 not run

1def save_session(
2        self, app: Flask, session: SessionMixin, response: Response
3    ) -> None:
4        name = self.get_cookie_name(app)
5        domain = self.get_cookie_domain(app)
6        path = self.get_cookie_path(app)
7        secure = self.get_cookie_secure(app)
8        samesite = self.get_cookie_samesite(app)
9        httponly = self.get_cookie_httponly(app)
10
11        # Add a "Vary: Cookie" header if the session was accessed at all.
12        if session.accessed:
13            response.vary.add("Cookie")
14
15        # If the session is modified to be empty, remove the cookie.
16        # If the session is empty, return without setting the cookie.
17        if not session:
18            if session.modified:
19                response.delete_cookie(
20                    name,
21                    domain=domain,
22                    path=path,
23                    secure=secure,
24                    samesite=samesite,
25                    httponly=httponly,
26                )
27                response.vary.add("Cookie")
28
29            return
30
31        if not self.should_set_cookie(app, session):
32            return
33
34        expires = self.get_expiration_time(app, session)
35        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
36        response.set_cookie(
37            name,
38            val,  # type: ignore
39            expires=expires,
40            httponly=httponly,
41            domain=domain,
42            path=path,
43            secure=secure,
44            samesite=samesite,
45        )
46        response.vary.add("Cookie")