summaryrefslogtreecommitdiff
path: root/indra/llplugin/tests/llplugincookiestore_test.cpp
blob: cc8663285fffd1916b915bab78e6cc6b455ebe50 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
/** 
 * @file llplugincookiestore_test.cpp
 * @brief Unit tests for LLPluginCookieStore.
 *
 * @cond
 * $LicenseInfo:firstyear=2010&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 * @endcond
 */

#include "linden_common.h"
#include "../test/lltut.h"

#include "../llplugincookiestore.h"


namespace tut
{
	// Main Setup
	struct LLPluginCookieStoreFixture
	{
		LLPluginCookieStoreFixture()
		{
			// We need dates definitively in the past and the future to properly test cookie expiration.
			LLDate now = LLDate::now(); 
			LLDate past(now.secondsSinceEpoch() - (60.0 * 60.0 * 24.0));	// 1 day in the past
			LLDate future(now.secondsSinceEpoch() + (60.0 * 60.0 * 24.0));	// 1 day in the future
			
			mPastString = past.asRFC1123();
			mFutureString = future.asRFC1123();
		}
		
		std::string mPastString;
		std::string mFutureString;
		LLPluginCookieStore mCookieStore;
		
		// List of cookies used for validation
		std::list<std::string> mCookies;
		
		// This sets up mCookies from a string returned by one of the functions in LLPluginCookieStore
		void setCookies(const std::string &cookies)
		{
			mCookies.clear();
			std::string::size_type start = 0;

			while(start != std::string::npos)
			{
				std::string::size_type end = cookies.find_first_of("\r\n", start);
				if(end > start)
				{
					std::string line(cookies, start, end - start);
					if(line.find_first_not_of("\r\n\t ") != std::string::npos)
					{
						// The line has some non-whitespace characters.  Save it to the list.
						mCookies.push_back(std::string(cookies, start, end - start));
					}
				}
				start = cookies.find_first_not_of("\r\n ", end);
			}
		}
		
		// This ensures that a cookie matching the one passed is in the list.
		void ensureCookie(const std::string &cookie)
		{
			std::list<std::string>::iterator iter;
			for(iter = mCookies.begin(); iter != mCookies.end(); iter++)
			{
				if(*iter == cookie)
				{
					// Found the cookie
					// TODO: this should do a smarter equality comparison on the two cookies, instead of just a string compare.
					return;
				}
			}
			
			// Didn't find this cookie
			std::string message = "cookie not found: ";
			message += cookie;
			ensure(message, false);
		}
		
		// This ensures that the number of cookies in the list matches what's expected.
		void ensureSize(const std::string &message, size_t size)
		{
			if(mCookies.size() != size)
			{
				std::stringstream full_message;
				
				full_message << message << " (expected " << size << ", actual " << mCookies.size() << ")";
				ensure(full_message.str(), false);
			}
		}
	};
	
	typedef test_group<LLPluginCookieStoreFixture> factory;
	typedef factory::object object;
	factory tf("LLPluginCookieStore test");

	// Tests
	template<> template<>
	void object::test<1>()
	{
		// Test 1: cookie uniqueness and update lists.
		// Valid, distinct cookies:
		
		std::string cookie01 = "cookieA=value; domain=example.com; path=/";
		std::string cookie02 = "cookieB=value; Domain=example.com; Path=/; Max-Age=10; Secure; Version=1; Comment=foo!; HTTPOnly"; // cookie with every supported field, in different cases.
		std::string cookie03 = "cookieA=value; domain=foo.example.com; path=/"; // different domain
		std::string cookie04 = "cookieA=value; domain=example.com; path=/bar/"; // different path
		std::string cookie05 = "cookieC; domain=example.com; path=/"; // empty value
		std::string cookie06 = "cookieD=value; domain=example.com; path=/; expires="; // different name, persistent cookie
		cookie06 += mFutureString;
		
		mCookieStore.setCookies(cookie01);
		mCookieStore.setCookies(cookie02);
		mCookieStore.setCookies(cookie03);
		mCookieStore.setCookies(cookie04);
		mCookieStore.setCookies(cookie05);
		mCookieStore.setCookies(cookie06);
		
		// Invalid cookies (these will get parse errors and not be added to the store)

		std::string badcookie01 = "cookieD=value; domain=example.com; path=/; foo=bar"; // invalid field name
		std::string badcookie02 = "cookieE=value; path=/"; // no domain

		mCookieStore.setCookies(badcookie01);
		mCookieStore.setCookies(badcookie02);
		
		// All cookies added so far should have been marked as "changed"
		setCookies(mCookieStore.getChangedCookies());
		ensureSize("count of changed cookies", 6);
		ensureCookie(cookie01);
		ensureCookie(cookie02);
		ensureCookie(cookie03);
		ensureCookie(cookie04);
		ensureCookie(cookie05);
		ensureCookie(cookie06);
		
		// Save off the current state of the cookie store (we'll restore it later)
		std::string savedCookies = mCookieStore.getAllCookies();
		
		// Test replacing cookies
		std::string cookie01a = "cookieA=newvalue; domain=example.com; path=/";	// updated value
		std::string cookie02a = "cookieB=newvalue; domain=example.com; path=/; expires="; // remove cookie (by setting an expire date in the past)
		cookie02a += mPastString;
		
		mCookieStore.setCookies(cookie01a);
		mCookieStore.setCookies(cookie02a);

		// test for getting changed cookies
		setCookies(mCookieStore.getChangedCookies());
		ensureSize("count of updated cookies", 2);
		ensureCookie(cookie01a);
		ensureCookie(cookie02a);
		
		// and for the state of the store after getting changed cookies
		setCookies(mCookieStore.getAllCookies());
		ensureSize("count of valid cookies", 5);
		ensureCookie(cookie01a);
		ensureCookie(cookie03);
		ensureCookie(cookie04);
		ensureCookie(cookie05);
		ensureCookie(cookie06);

		// Check that only the persistent cookie is returned here
		setCookies(mCookieStore.getPersistentCookies());
		ensureSize("count of persistent cookies", 1);
		ensureCookie(cookie06);

		// Restore the cookie store to a previous state and verify
		mCookieStore.setAllCookies(savedCookies);
		
		// Since setAllCookies defaults to not marking cookies as changed, this list should be empty.
		setCookies(mCookieStore.getChangedCookies());
		ensureSize("count of changed cookies after restore", 0);

		// Verify that the restore worked as it should have.
		setCookies(mCookieStore.getAllCookies());
		ensureSize("count of restored cookies", 6);
		ensureCookie(cookie01);
		ensureCookie(cookie02);
		ensureCookie(cookie03);
		ensureCookie(cookie04);
		ensureCookie(cookie05);
		ensureCookie(cookie06);
	}

}