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