1: <?php
  2: require_once(__DIR__."/../../../TestCase.php");
  3: 
  4: use Azalea\Core\Cookie\CookieManager;
  5: use Azalea\Shared\Variants\VariantsManager;
  6: 
  7: class VariantsManagerTest extends TestCase
  8: {
  9:     public function testCreateVariantManager()
 10:     {
 11:         $variants = new VariantsManager(array());
 12:         $this->assertTrue(true);
 13:     }
 14: 
 15:     public function testSimpleConstantConfiguration()
 16:     {
 17:         $variants = new VariantsManager(array(
 18:             "foo" => "bar"
 19:         ));
 20: 
 21:         // load not called yet
 22:         $this->assertFalse($variants->test("foo", "bar"));
 23: 
 24:         // load
 25:         $variants->load(array());
 26:         $this->assertTrue($variants->test("foo", "bar"));
 27:         $this->assertFalse($variants->test("bar", "foo"));
 28:         $this->assertEquals("bar", $variants->get("foo"));
 29:         $this->assertEquals("", $variants->get("bar"));
 30:     }
 31: 
 32:     public function testSimpleDeafultConfiguration()
 33:     {
 34:         $variants = new VariantsManager(array(
 35:             "foo" => array(
 36:                 "default" => "bar"
 37:             )
 38:         ));
 39: 
 40:         // load not called yet
 41:         $this->assertFalse($variants->test("foo", "bar"));
 42: 
 43:         // load
 44:         $variants->load(array());
 45:         $this->assertTrue($variants->test("foo", "bar"));
 46:         $this->assertFalse($variants->test("bar", "foo"));
 47:         $this->assertEquals("bar", $variants->get("foo"));
 48:         $this->assertEquals("", $variants->get("bar"));
 49:     }
 50: 
 51:     public function testSimpleRuleConfigurationWithUnknownRule()
 52:     {
 53:         $variants = new VariantsManager(array(
 54:             "foo" => array(
 55:                 "values" => array(
 56:                     array(
 57:                         "value" => "1",
 58:                         "rules" => array(
 59:                             "userId" => 100
 60:                         )
 61:                     ),
 62:                     array(
 63:                         "value" => "2",
 64:                         "rules" => array(
 65:                             "userId" => array(200,201,202)
 66:                         )
 67:                     )
 68:                 ),
 69:             )
 70:         ));
 71: 
 72:         // load before rule is added
 73:         $variants->load(array("usr_id" => 100));
 74:         $this->assertFalse($variants->test("foo", "1"));
 75:         $this->assertEquals("", $variants->get("foo"));
 76: 
 77:         // add UserRule
 78:         $variants->addRules(array(
 79:             new Azalea\Shared\Variants\Rules\UserRule()
 80:         ));
 81: 
 82:         // load after rule is added
 83:         $variants->load(array("usr_id" => 100));
 84:         $this->assertTrue($variants->test("foo", "1"));
 85:         $this->assertEquals("1", $variants->get("foo"));
 86:     }
 87: 
 88:     public function testSimpleRuleConfigurationWithoutDefault()
 89:     {
 90:         $variants = new VariantsManager(array(
 91:             "foo" => array(
 92:                 "values" => array(
 93:                     array(
 94:                         "value" => "1",
 95:                         "rules" => array(
 96:                             "userId" => 100
 97:                         )
 98:                     ),
 99:                     array(
100:                         "value" => "2",
101:                         "rules" => array(
102:                             "userId" => array(200,201,202)
103:                         )
104:                     )
105:                 ),
106:             )
107:         ));
108: 
109:         // add UserRule
110:         $variants->addRules(array(
111:             new Azalea\Shared\Variants\Rules\UserRule()
112:         ));
113: 
114:         // load not called yet
115:         $this->assertFalse($variants->test("foo", "bar"));
116: 
117:         // load empty
118:         $variants->load(array());
119:         $this->assertFalse($variants->test("foo", "bar"));
120:         $this->assertFalse($variants->test("bar", "foo"));
121:         $this->assertEquals("", $variants->get("foo"));
122:         $this->assertEquals("", $variants->get("bar"));
123: 
124:         // load with user id 100
125:         $variants->load(array("usr_id" => 100));
126:         $this->assertEquals("1", $variants->get("foo"));
127: 
128:         // load with user id 200
129:         $variants->load(array("usr_id" => 200));
130:         $this->assertEquals("2", $variants->get("foo"));
131: 
132:         // load with user id 201
133:         $variants->load(array("usr_id" => 201));
134:         $this->assertEquals("2", $variants->get("foo"));
135: 
136:         // load with user id 202
137:         $variants->load(array("usr_id" => 202));
138:         $this->assertEquals("2", $variants->get("foo"));
139: 
140:         // load with user id 300
141:         $variants->load(array("usr_id" => 300));
142:         $this->assertEquals("", $variants->get("foo"));
143:     }
144: 
145:     public function testSimpleRuleConfigurationWithDefault()
146:     {
147:         $variants = new VariantsManager(array(
148:             "foo" => array(
149:                 "values" => array(
150:                     array(
151:                         "value" => "1",
152:                         "rules" => array(
153:                             "userId" => 100
154:                         )
155:                     ),
156:                     array(
157:                         "value" => "2",
158:                         "rules" => array(
159:                             "userId" => array(200,201,202)
160:                         )
161:                     )
162:                 ),
163:                 "default" => "bar"
164:             )
165:         ));
166: 
167:         // add UserRule
168:         $variants->addRules(array(
169:             new Azalea\Shared\Variants\Rules\UserRule()
170:         ));
171: 
172:         // load not called yet
173:         $this->assertFalse($variants->test("foo", "bar"));
174: 
175:         // load empty
176:         $variants->load(array());
177:         $this->assertTrue($variants->test("foo", "bar"));
178:         $this->assertFalse($variants->test("bar", "foo"));
179:         $this->assertEquals("bar", $variants->get("foo"));
180:         $this->assertEquals("", $variants->get("bar"));
181: 
182:         // load with user id 100
183:         $variants->load(array("usr_id" => 100));
184:         $this->assertEquals("1", $variants->get("foo"));
185: 
186:         // load with user id 200
187:         $variants->load(array("usr_id" => 200));
188:         $this->assertEquals("2", $variants->get("foo"));
189: 
190:         // load with user id 201
191:         $variants->load(array("usr_id" => 201));
192:         $this->assertEquals("2", $variants->get("foo"));
193: 
194:         // load with user id 202
195:         $variants->load(array("usr_id" => 202));
196:         $this->assertEquals("2", $variants->get("foo"));
197: 
198:         // load with user id 300
199:         $variants->load(array("usr_id" => 300));
200:         $this->assertEquals("bar", $variants->get("foo"));
201:     }
202: 
203:     public function testMultipleRuleConfigurationWithDefault()
204:     {
205:         $variants = new VariantsManager(array(
206:             "foo" => array(
207:                 "values" => array(
208:                     array(
209:                         "value" => "1",
210:                         "rules" => array(
211:                             "customerId" => 8,
212:                             "userId" => 100
213:                         )
214:                     ),
215:                     array(
216:                         "value" => "2",
217:                         "rules" => array(
218:                             "customerId" => array(8, 99),
219:                             "userId" => array(200,201,202)
220:                         )
221:                     )
222:                 ),
223:                 "default" => "bar"
224:             )
225:         ));
226: 
227:         // add rules
228:         $variants->addRules(array(
229:             new Azalea\Shared\Variants\Rules\CustomerRule(),
230:             new Azalea\Shared\Variants\Rules\UserRule()
231:         ));
232: 
233:         $variants->load(array("usr_id" => 100));
234:         $this->assertEquals("bar", $variants->get("foo"));
235: 
236:         $variants->load(array("cus_id" => 8, "usr_id" => 100));
237:         $this->assertEquals("1", $variants->get("foo"));
238: 
239:         $variants->load(array("cus_id" => 1, "usr_id" => 200));
240:         $this->assertEquals("bar", $variants->get("foo"));
241: 
242:         $variants->load(array("cus_id" => 8, "usr_id" => 200));
243:         $this->assertEquals("2", $variants->get("foo"));
244:     }
245: 
246:     public function testMultipleRuleConfigurationWithoutDefault()
247:     {
248:         $variants = new VariantsManager(array(
249:             "foo" => array(
250:                 "values" => array(
251:                     array(
252:                         "value" => "1",
253:                         "rules" => array(
254:                             "customerId" => 8,
255:                             "userId" => 100
256:                         )
257:                     ),
258:                     array(
259:                         "value" => "2",
260:                         "rules" => array(
261:                             "customerId" => array(8, 99),
262:                             "userId" => array(200,201,202)
263:                         )
264:                     )
265:                 ),
266:             )
267:         ));
268: 
269:         // add rules
270:         $variants->addRules(array(
271:             new Azalea\Shared\Variants\Rules\CustomerRule(),
272:             new Azalea\Shared\Variants\Rules\UserRule()
273:         ));
274: 
275:         $variants->load(array("usr_id" => 100));
276:         $this->assertEquals("", $variants->get("foo"));
277: 
278:         $variants->load(array("cus_id" => 8, "usr_id" => 100));
279:         $this->assertEquals("1", $variants->get("foo"));
280: 
281:         $variants->load(array("cus_id" => 1, "usr_id" => 200));
282:         $this->assertEquals("", $variants->get("foo"));
283: 
284:         $variants->load(array("cus_id" => 8, "usr_id" => 200));
285:         $this->assertEquals("2", $variants->get("foo"));
286:     }
287: 
288:     public function testMultipleRuleConfigurationWithoutSameValues()
289:     {
290:         $variants = new VariantsManager(array(
291:             "foo" => array(
292:                 "values" => array(
293:                     array(
294:                         "value" => "1",
295:                         "rules" => array(
296:                             "userId" => 100
297:                         )
298:                     ),
299:                     array(
300:                         "value" => "1",
301:                         "rules" => array(
302:                             "customerId" => 8
303:                         )
304:                     ),
305:                     array(
306:                         "value" => "1",
307:                         "rules" => array(
308:                             "isAzaleaUser" => true
309:                         )
310:                     )
311:                 ),
312:             )
313:         ));
314: 
315:         // add rules
316:         $variants->addRules(array(
317:             new Azalea\Shared\Variants\Rules\AzaleaUserRule(),
318:             new Azalea\Shared\Variants\Rules\CustomerRule(),
319:             new Azalea\Shared\Variants\Rules\UserRule()
320:         ));
321: 
322:         $variants->load(array("usr_id" => 100));
323:         $this->assertEquals("1", $variants->get("foo"));
324: 
325:         $variants->load(array("cus_id" => 8));
326:         $this->assertEquals("1", $variants->get("foo"));
327: 
328:         $variants->load(array("is_ahi" => true));
329:         $this->assertEquals("1", $variants->get("foo"));
330: 
331:         // combos
332:         $variants->load(array("cus_id" => 8, "usr_id" => 100));
333:         $this->assertEquals("1", $variants->get("foo"));
334: 
335:         $variants->load(array("cus_id" => 8, "usr_id" => 100, "is_ahi" => true));
336:         $this->assertEquals("1", $variants->get("foo"));
337: 
338:         $variants->load(array("cus_id" => 8, "usr_id" => 100, "is_ahi" => false));
339:         $this->assertEquals("1", $variants->get("foo"));
340: 
341:         $variants->load(array("cus_id" => 8, "usr_id" => 200, "is_ahi" => false));
342:         $this->assertEquals("1", $variants->get("foo"));
343: 
344:         $variants->load(array("cus_id" => 5, "usr_id" => 200, "is_ahi" => false));
345:         $this->assertEquals("", $variants->get("foo"));
346:     }
347: 
348:     public function testLoadFromString()
349:     {
350:         $variants = new VariantsManager(array());
351:         $variants->loadFromString("foo=bar&baz=buzz");
352: 
353:         $this->assertTrue($variants->test("foo", "bar"));
354:         $this->assertTrue($variants->test("baz", "buzz"));
355:     }
356: 
357:     public function testLoadFromCookie()
358:     {
359:         $variants = new VariantsManager(array());
360:         $cookie = new CookieManager("www.example.com", "/");
361:         $cookie->set("variants", "foo=bar&baz=buzz");
362:         $variants->loadFromCookie($cookie);
363: 
364:         $this->assertTrue($variants->test("foo", "bar"));
365:         $this->assertTrue($variants->test("baz", "buzz"));
366:     }
367: 
368:     public function testSetAsCookie()
369:     {
370:         $variants = new VariantsManager(array(
371:             "foo" => array(
372:                 "values" => array(
373:                     array(
374:                         "value" => "bar",
375:                         "rules" => array(
376:                             "userId" => 100
377:                         )
378:                     ),
379:                     array(
380:                         "value" => "baz",
381:                         "rules" => array(
382:                             "customerId" => 8,
383:                             "clientId" => 1300,
384:                             "isAzaleaUser" => true
385:                         )
386:                     )
387:                 )
388:             )
389:         ));
390: 
391:         // add rules
392:         $variants->addRules(array(
393:             new Azalea\Shared\Variants\Rules\AzaleaUserRule(),
394:             new Azalea\Shared\Variants\Rules\ClientRule(),
395:             new Azalea\Shared\Variants\Rules\CustomerRule(),
396:             new Azalea\Shared\Variants\Rules\UserRule()
397:         ));
398: 
399:         $cookie = new CookieManager("www.example.com", "/");
400: 
401:         // no options
402:         $variants->load(array());
403:         $variants->setAsCookie($cookie);
404:         $this->assertEquals("", $cookie->get("variants"));
405: 
406:         // test options that match
407:         $variants->load(array(
408:             "usr_id" => 100
409:         ));
410:         $variants->setAsCookie($cookie);
411:         $this->assertEquals("foo=bar", $cookie->get("variants"));
412: 
413:         $variants->load(array(
414:             "cus_id" => 8,
415:             "cli_id" => 1300,
416:             "is_ahi" => true
417:         ));
418:         $variants->setAsCookie($cookie);
419:         $this->assertEquals("foo=baz", $cookie->get("variants"));
420:     }
421: 
422:     public function testSetAsCookieWithMultipleKeys()
423:     {
424:         $variants = new VariantsManager(array(
425:             "foo" => array(
426:                 "values" => array(
427:                     array(
428:                         "value" => "bar",
429:                         "rules" => array(
430:                             "userId" => 100
431:                         )
432:                     ),
433:                     array(
434:                         "value" => "baz",
435:                         "rules" => array(
436:                             "customerId" => 8,
437:                             "clientId" => 1300,
438:                             "isAzaleaUser" => true
439:                         )
440:                     )
441:                 )
442:             ),
443:             "fuzz" => "A"
444:         ));
445: 
446:         // add rules
447:         $variants->addRules(array(
448:             new Azalea\Shared\Variants\Rules\AzaleaUserRule(),
449:             new Azalea\Shared\Variants\Rules\ClientRule(),
450:             new Azalea\Shared\Variants\Rules\CustomerRule(),
451:             new Azalea\Shared\Variants\Rules\UserRule()
452:         ));
453: 
454:         $cookie = new CookieManager("www.example.com", "/");
455: 
456:         // no options
457:         $variants->load(array());
458:         $variants->setAsCookie($cookie);
459:         $this->assertEquals("fuzz=A", $cookie->get("variants"));
460: 
461:         // test options that match
462:         $variants->load(array(
463:             "usr_id" => 100
464:         ));
465:         $variants->setAsCookie($cookie);
466:         $this->assertEquals("foo=bar&fuzz=A", $cookie->get("variants"));
467: 
468:         $variants->load(array(
469:             "cus_id" => 8,
470:             "cli_id" => 1300,
471:             "is_ahi" => true
472:         ));
473:         $variants->setAsCookie($cookie);
474:         $this->assertEquals("foo=baz&fuzz=A", $cookie->get("variants"));
475:     }
476: }
477: 
478: ?>