Examples with Entitlement org.candlepin.model.Entitlement used on opensource projects

Example 66 with Entitlement

use of org.candlepin.model.Entitlement in project candlepin by candlepin.

the class ExportRulesTest method canExportProductConsumer.

@Test
public void canExportProductConsumer() throws NoSuchMethodException {
    Entitlement entitlement = mock(Entitlement.class);
    Consumer consumer = mock(Consumer.class);
    ConsumerType consumerType = new ConsumerType("system");
    consumerType.setId("consumer_type");
    Pool pool = mock(Pool.class);
    Product product = mock(Product.class);
    Map<String, String> attributes = new HashMap<>();
    attributes.put(Pool.Attributes.DERIVED_POOL, "true");
    when(entitlement.getPool()).thenReturn(pool);
    when(entitlement.getConsumer()).thenReturn(consumer);
    when(pool.getProductId()).thenReturn("12345");
    when(product.getAttributes()).thenReturn(new HashMap<>());
    when(pool.getAttributes()).thenReturn(attributes);
    when(consumer.getTypeId()).thenReturn(consumerType.getId());
    when(consumerTypeCuratorMock.find(eq(consumerType.getId()))).thenReturn(consumerType);
    when(consumerTypeCuratorMock.getConsumerType(eq(consumer))).thenReturn(consumerType);
    assertTrue(exportRules.canExport(entitlement));
}

Example 67 with Entitlement

use of org.candlepin.model.Entitlement in project candlepin by candlepin.

the class PoolRulesStackDerivedTest method createEntFromPool.

private Entitlement createEntFromPool(Pool pool) {
    Entitlement e = new Entitlement(pool, consumer, owner, 2);
    e.setCreated(new Date());
    try {
        Thread.sleep(1);
    } catch (InterruptedException e1) {
        e1.printStackTrace();
    }
    return e;
}

Example 68 with Entitlement

use of org.candlepin.model.Entitlement in project candlepin by candlepin.

the class PoolRulesStackDerivedTest method virtLimitFromFirstVirtLimitEntBatch.

@Test
public void virtLimitFromFirstVirtLimitEntBatch() {
    CandlepinQuery cqmock = mock(CandlepinQuery.class);
    stackedEnts.clear();
    Entitlement e1 = createEntFromPool(pool1);
    e1.setQuantity(4);
    stackedEnts.add(e1);
    Entitlement e2 = createEntFromPool(pool4);
    e2.setQuantity(16);
    stackedEnts.add(e2);
    Class<Set<String>> listClass = (Class<Set<String>>) (Class) HashSet.class;
    ArgumentCaptor<Set<String>> arg = ArgumentCaptor.forClass(listClass);
    when(cqmock.iterator()).thenReturn(stackedEnts.iterator());
    when(entCurMock.findByStackIds(eq(consumer), arg.capture())).thenReturn(cqmock);
    List<PoolUpdate> updates = poolRules.updatePoolsFromStack(consumer, Arrays.asList(stackDerivedPool, stackDerivedPool2), false);
    Set<String> stackIds = arg.getValue();
    assertEquals(2, stackIds.size());
    assertThat(stackIds, hasItems(STACK, STACK + "3"));
    for (PoolUpdate update : updates) {
        assertTrue(update.changed());
        assertTrue(update.getQuantityChanged());
    }
    assertEquals((Long) 2L, stackDerivedPool.getQuantity());
    assertEquals((Long) 9L, stackDerivedPool2.getQuantity());
}

Example 69 with Entitlement

use of org.candlepin.model.Entitlement in project candlepin by candlepin.

the class PoolRulesStackDerivedTest method setUp.

@Before
public void setUp() {
    // Load the default production rules:
    InputStream is = this.getClass().getResourceAsStream(RulesCurator.DEFAULT_RULES_FILE);
    Rules rules = new Rules(Util.readFile(is));
    when(rulesCuratorMock.getUpdated()).thenReturn(new Date());
    when(rulesCuratorMock.getRules()).thenReturn(rules);
    when(configMock.getInt(eq(ConfigProperties.PRODUCT_CACHE_MAX))).thenReturn(100);
    poolRules = new PoolRules(poolManagerMock, configMock, entCurMock, ownerProductCuratorMock, productCurator);
    principal = TestUtil.createOwnerPrincipal();
    owner = principal.getOwners().get(0);
    ConsumerType ctype = new ConsumerType(ConsumerTypeEnum.SYSTEM);
    ctype.setId("test-ctype");
    consumer = new Consumer("consumer", "registeredbybob", owner, ctype);
    // Two subtly different products stacked together:
    prod1 = TestUtil.createProduct("prod1", "prod1");
    prod1.setAttribute(Product.Attributes.VIRT_LIMIT, "2");
    prod1.setAttribute(Product.Attributes.STACKING_ID, STACK);
    prod1.setAttribute("testattr1", "1");
    when(ownerProductCuratorMock.getProductById(owner, prod1.getId())).thenReturn(prod1);
    prod2 = TestUtil.createProduct("prod2", "prod2");
    prod2.setAttribute(Product.Attributes.VIRT_LIMIT, "unlimited");
    prod2.setAttribute(Product.Attributes.STACKING_ID, STACK);
    prod2.setAttribute("testattr2", "2");
    when(ownerProductCuratorMock.getProductById(owner, prod2.getId())).thenReturn(prod2);
    prod3 = TestUtil.createProduct("prod3", "prod3");
    prod3.setAttribute(Product.Attributes.VIRT_LIMIT, "9");
    prod3.setAttribute(Product.Attributes.STACKING_ID, STACK + "3");
    prod3.setAttribute("testattr2", "2");
    when(ownerProductCuratorMock.getProductById(owner, prod3.getId())).thenReturn(prod3);
    provided1 = TestUtil.createProduct();
    provided2 = TestUtil.createProduct();
    provided3 = TestUtil.createProduct();
    provided4 = TestUtil.createProduct();
    // Create three subscriptions with various start/end dates:
    sub1 = createStackedVirtSub(owner, prod1, TestUtil.createDate(2010, 1, 1), TestUtil.createDate(2015, 1, 1));
    sub1.getProvidedProducts().add(provided1.toDTO());
    pool1 = copyFromSub(sub1);
    sub2 = createStackedVirtSub(owner, prod2, TestUtil.createDate(2011, 1, 1), TestUtil.createDate(2017, 1, 1));
    sub2.getProvidedProducts().add(provided2.toDTO());
    pool2 = copyFromSub(sub2);
    sub3 = createStackedVirtSub(owner, prod2, TestUtil.createDate(2012, 1, 1), TestUtil.createDate(2020, 1, 1));
    sub3.getProvidedProducts().add(provided3.toDTO());
    pool3 = copyFromSub(sub3);
    sub4 = createStackedVirtSub(owner, prod3, TestUtil.createDate(2012, 1, 1), TestUtil.createDate(2020, 1, 1));
    sub4.getProvidedProducts().add(provided4.toDTO());
    pool4 = copyFromSub(sub4);
    // Initial entitlement from one of the pools:
    stackedEnts.add(createEntFromPool(pool2));
    CandlepinQuery cqmock = mock(CandlepinQuery.class);
    when(cqmock.list()).thenReturn(stackedEnts);
    when(entCurMock.findByStackId(consumer, STACK)).thenReturn(cqmock);
    pool2.setAttribute(Product.Attributes.VIRT_LIMIT, "60");
    pool4.setAttribute(Product.Attributes.VIRT_LIMIT, "80");
    List<Pool> reqPools = new ArrayList<>();
    reqPools.add(pool2);
    Map<String, Entitlement> entitlements = new HashMap<>();
    entitlements.put(pool2.getId(), stackedEnts.get(0));
    Map<String, Map<String, String>> attributes = new HashMap<>();
    attributes.put(pool2.getId(), PoolHelper.getFlattenedAttributes(pool2));
    when(poolManagerMock.createPools(Matchers.anyListOf(Pool.class))).then(returnsFirstArg());
    List<Pool> resPools = PoolHelper.createHostRestrictedPools(poolManagerMock, consumer, reqPools, entitlements, attributes, productCurator);
    stackDerivedPool = resPools.get(0);
    reqPools.clear();
    reqPools.add(pool4);
    entitlements.clear();
    entitlements.put(pool4.getId(), createEntFromPool(pool4));
    attributes.clear();
    attributes.put(pool4.getId(), PoolHelper.getFlattenedAttributes(pool4));
    stackDerivedPool2 = PoolHelper.createHostRestrictedPools(poolManagerMock, consumer, reqPools, entitlements, attributes, productCurator).get(0);
}

Example 70 with Entitlement

use of org.candlepin.model.Entitlement in project candlepin by candlepin.

the class PoolRulesStackDerivedTest method mergedProductAttributes.

@Test
public void mergedProductAttributes() {
    Entitlement ent1 = createEntFromPool(pool1);
    ent1.setCreated(new Date(System.currentTimeMillis() - 86400000));
    stackedEnts.add(ent1);
    stackedEnts.add(createEntFromPool(pool3));
    PoolUpdate update = poolRules.updatePoolFromStack(stackDerivedPool, null);
    assertTrue(update.changed());
    assertTrue(update.getProductAttributesChanged());
    assertEquals(pool1.getProductAttributes(), stackDerivedPool.getProductAttributes());
}