public override void Append(IHttpCookie cookie)
        {
            if (cookie is null)
            {
                throw new ArgumentNullException(nameof(cookie));
            }

            if (cookie is not RpcHttpCookie rpcCookie)
            {
                rpcCookie = new RpcHttpCookie(cookie);
            }

            _cookies.Add(rpcCookie);
        }
Exemple #2
0
        public static Tuple <string, string, CookieOptions> RpcHttpCookieConverter(RpcHttpCookie cookie)
        {
            var cookieOptions = new CookieOptions();

            if (cookie.Domain != null)
            {
                cookieOptions.Domain = cookie.Domain.Value;
            }

            if (cookie.Path != null)
            {
                cookieOptions.Path = cookie.Path.Value;
            }

            if (cookie.Secure != null)
            {
                cookieOptions.Secure = cookie.Secure.Value;
            }

            cookieOptions.SameSite = RpcSameSiteEnumConverter(cookie.SameSite);

            if (cookie.HttpOnly != null)
            {
                cookieOptions.HttpOnly = cookie.HttpOnly.Value;
            }

            if (cookie.Expires != null)
            {
                cookieOptions.Expires = cookie.Expires.Value.ToDateTimeOffset();
            }

            if (cookie.MaxAge != null)
            {
                cookieOptions.MaxAge = TimeSpan.FromSeconds(cookie.MaxAge.Value);
            }

            return(new Tuple <string, string, CookieOptions>(cookie.Name, cookie.Value, cookieOptions));
        }
Exemple #3
0
        public void SetCookie_ReturnsExpectedResult(string name, string value, RpcHttpCookie.Types.SameSite sameSite, string expires,
                                                    string domain, bool?httpOnly, double?maxAge, string path, bool?secure)
        {
            // Mock rpc cookie
            var rpcCookie = new RpcHttpCookie()
            {
                Name     = name,
                Value    = value,
                SameSite = sameSite
            };

            if (!string.IsNullOrEmpty(domain))
            {
                rpcCookie.Domain = new NullableString()
                {
                    Value = domain
                };
            }

            if (!string.IsNullOrEmpty(path))
            {
                rpcCookie.Path = new NullableString()
                {
                    Value = path
                };
            }

            if (maxAge.HasValue)
            {
                rpcCookie.MaxAge = new NullableDouble()
                {
                    Value = maxAge.Value
                };
            }

            DateTimeOffset?expiresDateTime = null;

            if (!string.IsNullOrEmpty(expires))
            {
                if (DateTimeOffset.TryParse(expires, out DateTimeOffset result))
                {
                    expiresDateTime   = result;
                    rpcCookie.Expires = new NullableTimestamp()
                    {
                        Value = result.ToTimestamp()
                    };
                }
            }

            if (httpOnly.HasValue)
            {
                rpcCookie.HttpOnly = new NullableBool()
                {
                    Value = httpOnly.Value
                };
            }

            if (secure.HasValue)
            {
                rpcCookie.Secure = new NullableBool()
                {
                    Value = secure.Value
                };
            }

            var appendCookieArguments = Utilities.RpcHttpCookieConverter(rpcCookie);

            Assert.Equal(appendCookieArguments.Item1, name);
            Assert.Equal(appendCookieArguments.Item2, value);

            var cookieOptions = appendCookieArguments.Item3;

            Assert.Equal(cookieOptions.Domain, domain);
            Assert.Equal(cookieOptions.Path, path ?? "/");

            Assert.Equal(cookieOptions.MaxAge?.TotalSeconds, maxAge);
            Assert.Equal(cookieOptions.Expires?.UtcDateTime.ToString(), expiresDateTime?.UtcDateTime.ToString());

            Assert.Equal(cookieOptions.Secure, secure ?? false);
            Assert.Equal(cookieOptions.HttpOnly, httpOnly ?? false);
        }