// NOTE: This scenario should NEVER happen since listByConsumerAndDate should
  //       never return dates before the specified date. This test exists to
  //       test the guard clauses in the ComplianceRulesHelper in case it ever happened.
  @Test
  public void expiredEntitlementIsIgnoredWhenCalculatingCompliantUntilDate() {
    Consumer consumer = mockConsumer(new String[] {PRODUCT_1});

    Date start = TestUtil.createDate(2005, 6, 12);

    Entitlement expired =
        mockEntitlement(
            consumer,
            "Provides Product 1 past Ent3",
            TestUtil.createDate(2005, 5, 20),
            TestUtil.createDate(2005, 6, 2),
            PRODUCT_1);

    Entitlement ent =
        mockEntitlement(
            consumer,
            "Provides Product 1 For Short Period",
            start,
            TestUtil.createDate(2005, 6, 22),
            PRODUCT_1);

    // Set up entitlements at specific dates.
    when(entCurator.listByConsumerAndDate(eq(consumer), eq(start)))
        .thenReturn(Arrays.asList(expired, ent));

    when(entCurator.listByConsumerAndDate(eq(consumer), eq(addSecond(ent.getEndDate()))))
        .thenReturn(Arrays.asList(new Entitlement[0]));

    Date expectedDate = addSecond(ent.getEndDate());
    ComplianceStatus status = compliance.getStatus(consumer, start);
    assertEquals(expectedDate, status.getCompliantUntil());
  }
Example #2
0
  @Test
  public void testFutureSuggested() {
    consumer.setFact(SOCKET_FACT, "4");

    pool.setStartDate(TestUtil.createDate(9000, 1, 1));
    pool.setEndDate(TestUtil.createDate(9001, 1, 1));

    Pool currentPool = TestUtil.createPool(owner, product);
    currentPool.setStartDate(TestUtil.createDate(2000, 1, 1));
    currentPool.setEndDate(TestUtil.createDate(5000, 1, 1));
    currentPool.getProduct().setAttribute("multi-entitlement", "yes");
    currentPool.getProduct().setAttribute("stacking_id", "1");

    pool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "2");
    currentPool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "2");

    Entitlement currentEntitlement = TestUtil.createEntitlement(owner, consumer, currentPool, null);
    currentEntitlement.setQuantity(2);

    Set<Entitlement> ents = new HashSet<Entitlement>();
    ents.add(currentEntitlement);
    consumer.setEntitlements(ents);

    SuggestedQuantity suggested =
        quantityRules.getSuggestedQuantity(currentPool, consumer, TestUtil.createDate(2010, 6, 1));
    assertEquals(new Long(0), suggested.getSuggested());

    // Make sure current coverage does not affect the future
    suggested = quantityRules.getSuggestedQuantity(pool, consumer, TestUtil.createDate(9000, 6, 1));
    assertEquals(new Long(2), suggested.getSuggested());
  }
Example #3
0
  @Test(expected = ExportCreationException.class)
  public void doNotExportDirtyEntitlements() throws Exception {
    config.setProperty(ConfigProperties.SYNC_WORK_DIR, "/tmp/");
    Consumer consumer = mock(Consumer.class);
    Entitlement ent = mock(Entitlement.class);
    Principal principal = mock(Principal.class);
    IdentityCertificate idcert = new IdentityCertificate();

    List<Entitlement> entitlements = new ArrayList<Entitlement>();
    entitlements.add(ent);

    when(pki.getSHA256WithRSAHash(any(InputStream.class))).thenReturn("signature".getBytes());
    when(pprov.get()).thenReturn(principal);
    when(principal.getUsername()).thenReturn("testUser");

    when(ec.listByConsumer(consumer)).thenReturn(entitlements);
    when(ent.getDirty()).thenReturn(true);
    idcert.setSerial(new CertificateSerial(10L, new Date()));
    idcert.setKey("euh0876puhapodifbvj094");
    idcert.setCert("hpj-08ha-w4gpoknpon*)&^%#");
    idcert.setCreated(new Date());
    idcert.setUpdated(new Date());
    when(consumer.getIdCert()).thenReturn(idcert);

    KeyPair keyPair = createKeyPair();
    when(consumer.getKeyPair()).thenReturn(keyPair);
    when(pki.getPemEncoded(keyPair.getPrivateKey())).thenReturn("privateKey".getBytes());
    when(pki.getPemEncoded(keyPair.getPublicKey())).thenReturn("publicKey".getBytes());

    Exporter e =
        new Exporter(
            ctc, me, ce, cte, re, ece, ecsa, pe, psa, pce, ec, ee, pki, config, exportRules, pprov);

    e.getFullExport(consumer);
  }
Example #4
0
  @Test
  public void testPhysicalIgnoresFutureConsumed() {
    // Setup a future pool for the same product:
    Pool futurePool = TestUtil.createPool(owner, product);
    futurePool.setStartDate(TestUtil.createDate(2050, 1, 1));
    futurePool.setEndDate(TestUtil.createDate(2060, 1, 1));

    pool.getProduct().setAttribute("multi-entitlement", "yes");
    pool.getProduct().setAttribute("stacking_id", "1");
    pool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "1");
    futurePool.getProduct().setAttribute("multi-entitlement", "yes");
    futurePool.getProduct().setAttribute("stacking_id", "1");
    futurePool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "1");

    consumer.setFact(SOCKET_FACT, "4");

    // Green in future but we have nothing now:
    Entitlement e = createValidEntitlement(futurePool);
    e.setQuantity(4);

    Set<Entitlement> ents = new HashSet<Entitlement>();
    ents.add(e);

    consumer.setEntitlements(ents);

    SuggestedQuantity suggested = quantityRules.getSuggestedQuantity(pool, consumer, new Date());
    assertEquals(new Long(4), suggested.getSuggested());
  }
Example #5
0
 @Test
 public void testLazyRegenerate() {
   Entitlement e = new Entitlement();
   manager.regenerateCertificatesOf(e, false, true);
   assertTrue(e.getDirty());
   verifyZeroInteractions(entCertAdapterMock);
 }
Example #6
0
  @Test
  public void testStackOnlyStacksWithSameStackingId() {
    consumer.setFact(IS_VIRT, "false");
    consumer.setFact(SOCKET_FACT, "8");
    pool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "2");
    pool.setQuantity(10L);
    Product product1 = TestUtil.createProduct();
    Pool pool1 = TestUtil.createPool(owner, product1);
    Entitlement e =
        TestUtil.createEntitlement(owner, consumer, pool1, new EntitlementCertificate());

    Set<Entitlement> entSet = new HashSet<Entitlement>();
    entSet.add(e);
    pool1.setEntitlements(entSet);
    pool1.getProduct().setAttribute("multi-entitlement", "yes");
    pool1.getProduct().setAttribute("stacking_id", "2");
    pool1.getProduct().setAttribute(SOCKET_ATTRIBUTE, "2");
    pool1.setQuantity(10L);

    // Consume 2 subscriptions with another stacking ID
    Entitlement toAdd = pool1.getEntitlements().iterator().next();
    toAdd.setQuantity(2);
    consumer.addEntitlement(toAdd);

    // Ensure the 2 attached entitlements do not cause the suggested quantity to change
    SuggestedQuantity suggested = quantityRules.getSuggestedQuantity(pool, consumer, new Date());
    assertEquals(new Long(4), suggested.getSuggested());
  }
 @Test
 public void listProvidingNoResults() {
   Entitlement ent = setupListProvidingEntitlement();
   Set<Entitlement> results =
       entitlementCurator.listProviding(
           consumer, "nosuchproductid", ent.getStartDate(), ent.getEndDate());
   assertEquals(0, results.size());
 }
Example #8
0
 private List<Pool> createPoolsWithSourceEntitlement(Entitlement e, Product p) {
   List<Pool> pools = new LinkedList<Pool>();
   Pool pool1 = TestUtil.createPool(e.getOwner(), p);
   pools.add(pool1);
   Pool pool2 = TestUtil.createPool(e.getOwner(), p);
   pools.add(pool2);
   return pools;
 }
 @Test
 public void listModifyingProvided() {
   Entitlement ent = setupListModifyingEntitlement();
   List<Entitlement> results =
       entitlementCurator.listModifying(
           consumer, providedProduct1.getId(), ent.getStartDate(), ent.getEndDate());
   assertEquals(1, results.size());
 }
 @Test
 public void listProvidingNoOverlap() {
   Entitlement ent = setupListProvidingEntitlement();
   Set<Entitlement> results =
       entitlementCurator.listProviding(
           consumer, ent.getPool().getProductId(), pastDate, pastDate);
   assertEquals(0, results.size());
 }
 @Test
 public void listModifyingNoResults() {
   Entitlement ent = setupListModifyingEntitlement();
   List<Entitlement> results =
       entitlementCurator.listModifying(
           consumer, "notarealproduct", ent.getStartDate(), ent.getEndDate());
   assertEquals(0, results.size());
 }
 @Test
 public void listProvidingStartDateOverlap() {
   Entitlement ent = setupListProvidingEntitlement();
   Set<Entitlement> results =
       entitlementCurator.listProviding(
           consumer, ent.getPool().getProductId(), overlappingDate, futureDate);
   assertEquals(1, results.size());
 }
Example #13
0
 @Test
 public void testLazyRegenerateForConsumer() {
   Entitlement e = new Entitlement();
   Consumer c = new Consumer();
   c.addEntitlement(e);
   manager.regenerateEntitlementCertificates(c, true);
   assertTrue(e.getDirty());
   verifyZeroInteractions(entCertAdapterMock);
 }
 private Set<Product> getDerivedProductsForDistributor(Subscription sub, Entitlement ent) {
   Set<Product> derivedProducts = new HashSet<Product>();
   boolean derived = ent.getPool().hasAttribute("pool_derived");
   if (!derived && ent.getConsumer().getType().isManifest() && sub.getDerivedProduct() != null) {
     derivedProducts.add(sub.getDerivedProduct());
     derivedProducts.addAll(sub.getDerivedProvidedProducts());
   }
   return derivedProducts;
 }
 @Test
 public void listProvidingProvidedProduct() {
   Entitlement ent = setupListProvidingEntitlement();
   // Test a successful query:
   Set<Entitlement> results =
       entitlementCurator.listProviding(
           consumer, providedProduct1.getId(), ent.getStartDate(), ent.getEndDate());
   assertEquals(1, results.size());
 }
Example #16
0
  @Test
  public void testRefreshPoolsRemovesExpiredSubscriptionsAlongWithItsPoolsAndEnts() {
    PreUnbindHelper preHelper = mock(PreUnbindHelper.class);

    Date expiredStart = TestUtil.createDate(2004, 5, 5);
    Date expiredDate = TestUtil.createDate(2005, 5, 5);

    List<Subscription> subscriptions = Util.newList();

    Subscription sub = TestUtil.createSubscription(getOwner(), TestUtil.createProduct());
    sub.setStartDate(expiredStart);
    sub.setEndDate(expiredDate);
    sub.setId("123");
    subscriptions.add(sub);

    when(mockSubAdapter.getSubscriptions(any(Owner.class))).thenReturn(subscriptions);

    List<Pool> pools = Util.newList();
    Pool p = TestUtil.createPool(sub.getOwner(), sub.getProduct());
    p.setSubscriptionId(sub.getId());
    p.setStartDate(expiredStart);
    p.setEndDate(expiredDate);
    p.setConsumed(1L);
    pools.add(p);

    when(mockPoolCurator.lockAndLoad(any(Pool.class))).thenReturn(p);

    when(mockPoolCurator.listAvailableEntitlementPools(
            any(Consumer.class),
            any(Owner.class),
            anyString(),
            any(Date.class),
            anyBoolean(),
            anyBoolean()))
        .thenReturn(pools);

    List<Entitlement> poolEntitlements = Util.newList();
    Entitlement ent = TestUtil.createEntitlement();
    ent.setPool(p);
    ent.setQuantity(1);
    poolEntitlements.add(ent);

    when(mockPoolCurator.entitlementsIn(eq(p))).thenReturn(poolEntitlements);

    ValidationResult result = new ValidationResult();
    when(preHelper.getResult()).thenReturn(result);

    this.manager.getRefresher().add(sub.getOwner()).run();

    verify(mockSubAdapter).deleteSubscription(eq(sub));
    verify(mockPoolCurator).delete(eq(p));

    // Verify the entitlement was removed.
    verify(entCertAdapterMock).revokeEntitlementCertificates(eq(ent));
    verify(entitlementCurator).delete(eq(ent));
  }
 private void postBindVirtLimit(
     PoolHelper postHelper,
     Entitlement entitlement,
     Pool pool,
     Consumer c,
     Map<String, String> attributes) {
   log.debug("Running virt_limit post-bind.");
   if (!c.isManifest() && (config.standalone() || attributes.containsKey("host_limited"))) {
     String productId = pool.getProductId();
     String virtLimit = attributes.get("virt_limit");
     if ("unlimited".equals(virtLimit)) {
       postHelper.createHostRestrictedPool(productId, pool, "unlimited");
     } else {
       int virtQuantity = Integer.parseInt(virtLimit) * entitlement.getQuantity();
       if (virtQuantity > 0) {
         postHelper.createHostRestrictedPool(productId, pool, String.valueOf(virtQuantity));
       }
     }
   } else {
     if (!config.standalone() && c.isManifest()) {
       String virtLimit = attributes.get("virt_limit");
       if (!"unlimited".equals(virtLimit)) {
         // if the bonus pool is not unlimited, then the bonus pool
         // quantity
         // needs to be adjusted based on the virt limit
         int virtQuantity = Integer.parseInt(virtLimit) * entitlement.getQuantity();
         if (virtQuantity > 0) {
           List<Pool> pools = postHelper.lookupBySubscriptionId(pool.getSubscriptionId());
           for (int idex = 0; idex < pools.size(); idex++) {
             Pool derivedPool = pools.get(idex);
             if (derivedPool.getAttributeValue("pool_derived") != null) {
               derivedPool = postHelper.updatePoolQuantity(derivedPool, -1 * virtQuantity);
             }
           }
         }
       } else {
         // if the bonus pool is unlimited, then the quantity needs
         // to go to 0
         // when the physical pool is exhausted completely by export.
         // A quantity of 0 will block future binds, whereas -1 does
         // not.
         if (pool.getQuantity().equals(pool.getExported())) {
           // getting all pools matching the sub id. Filtering out
           // the 'parent'.
           List<Pool> pools = postHelper.lookupBySubscriptionId(pool.getSubscriptionId());
           for (int idex = 0; idex < pools.size(); idex++) {
             Pool derivedPool = pools.get(idex);
             if (derivedPool.getAttributeValue("pool_derived") != null) {
               derivedPool = postHelper.setPoolQuantity(derivedPool, 0);
             }
           }
         }
       }
     }
   }
 }
  @Test
  public void entIsNotCompliantWhenSocketsAreNotCovered() {
    Consumer c = mock(Consumer.class);
    when(c.hasFact("cpu.cpu_socket(s)")).thenReturn(true);
    when(c.getFact("cpu.cpu_socket(s)")).thenReturn("8");

    Entitlement ent = mockEntitlement(c, PRODUCT_1);
    ent.getPool().setProductAttribute("sockets", "4", PRODUCT_1);
    assertFalse(compliance.isEntitlementCompliant(c, ent));
  }
  protected void runPostUnbind(PoolHelper postHelper, Entitlement entitlement) {
    Pool pool = entitlement.getPool();
    Consumer c = entitlement.getConsumer();

    Map<String, String> attributes = postHelper.getFlattenedAttributes(pool);

    if (attributes.containsKey("virt_limit")) {
      postUnbindVirtLimit(postHelper, entitlement, pool, c, attributes);
    }
  }
 /**
  * @param ent
  * @param useContentPrefix
  * @return
  * @throws IOException
  */
 private String getContentPrefix(Entitlement ent, boolean useContentPrefix) throws IOException {
   String contentPrefix = null;
   if (useContentPrefix) {
     contentPrefix = ent.getOwner().getContentPrefix();
     Environment env = ent.getConsumer().getEnvironment();
     if (contentPrefix != null && !contentPrefix.equals("")) {
       if (env != null) {
         contentPrefix = contentPrefix.replaceAll("\\$env", env.getName());
       }
       contentPrefix = this.cleanUpPrefix(contentPrefix);
     }
   }
   return contentPrefix;
 }
Example #21
0
  @Test
  public void testUnmappedGuestRevocation() throws Exception {
    Owner owner1 = new Owner("o1");
    Owner owner2 = new Owner("o2");

    Product product1 = TestUtil.createProduct();
    Product product2 = TestUtil.createProduct();

    Pool p1 = TestUtil.createPool(owner1, product1);
    Pool p2 = TestUtil.createPool(owner2, product2);

    p1.addAttribute(new PoolAttribute("unmapped_guests_only", "true"));
    p2.addAttribute(new PoolAttribute("unmapped_guests_only", "true"));

    Date thirtySixHoursAgo = new Date(new Date().getTime() - 36L * 60L * 60L * 1000L);
    Date twelveHoursAgo = new Date(new Date().getTime() - 12L * 60L * 60L * 1000L);

    Consumer c;
    c = TestUtil.createConsumer(owner1);
    c.setCreated(twelveHoursAgo);

    Entitlement e1 = TestUtil.createEntitlement(owner1, c, p1, null);
    e1.setEndDateOverride(new Date(new Date().getTime() + 1L * 60L * 60L * 1000L));
    Set<Entitlement> entitlementSet1 = new HashSet<Entitlement>();
    entitlementSet1.add(e1);

    p1.setEntitlements(entitlementSet1);

    c = TestUtil.createConsumer(owner2);
    c.setCreated(twelveHoursAgo);

    Entitlement e2 = TestUtil.createEntitlement(owner2, c, p2, null);
    e2.setEndDateOverride(thirtySixHoursAgo);
    Set<Entitlement> entitlementSet2 = new HashSet<Entitlement>();
    entitlementSet2.add(e2);

    p2.setEntitlements(entitlementSet2);

    CandlepinQuery cqmock = mock(CandlepinQuery.class);

    when(cqmock.iterator()).thenReturn(Arrays.asList(e1, e2).iterator());
    when(entitlementCurator.findByPoolAttribute(eq("unmapped_guests_only"), eq("true")))
        .thenReturn(cqmock);

    int total = entitler.revokeUnmappedGuestEntitlements();
    assertEquals(1, total);

    verify(pm).revokeEntitlement(e1);
  }
Example #22
0
  @Test
  public void testPhysicalAccountsForCurrentlyConsumed() {
    consumer.setFact(SOCKET_FACT, "4");
    pool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "1");

    Entitlement e = createValidEntitlement(pool);
    e.setQuantity(2);

    Set<Entitlement> ents = new HashSet<Entitlement>();
    ents.add(e);

    consumer.setEntitlements(ents);

    SuggestedQuantity suggested = quantityRules.getSuggestedQuantity(pool, consumer, new Date());
    assertEquals(new Long(2), suggested.getSuggested());
  }
 /**
  * @param ent
  * @return
  */
 private Map<String, EnvironmentContent> getPromotedContent(Entitlement ent) {
   // Build a set of all content IDs promoted to the consumer's environment so
   // we can determine if anything needs to be skipped:
   Map<String, EnvironmentContent> promotedContent = new HashMap<String, EnvironmentContent>();
   if (ent.getConsumer().getEnvironment() != null) {
     log.debug(
         "Consumer has environment, checking for promoted content in: "
             + ent.getConsumer().getEnvironment());
     for (EnvironmentContent envContent :
         ent.getConsumer().getEnvironment().getEnvironmentContent()) {
       log.debug("  promoted content: " + envContent.getContentId());
       promotedContent.put(envContent.getContentId(), envContent);
     }
   }
   return promotedContent;
 }
Example #24
0
  private Entitlement createValidEntitlement(Pool p) {
    Entitlement e = TestUtil.createEntitlement(owner, consumer, p, null);

    Calendar cal = Calendar.getInstance();
    cal.setTime(new Date());
    cal.add(Calendar.DATE, 1);

    Date dayFromNow = cal.getTime();

    cal.add(Calendar.DATE, -2);
    Date dayAgo = cal.getTime();

    e.setCreated(dayAgo);
    p.setEndDate(dayFromNow);
    return e;
  }
Example #25
0
  private Pool createPoolWithEntitlements() {
    Pool newPool = TestUtil.createPool(o, product);
    Entitlement e1 =
        new Entitlement(
            newPool, TestUtil.createConsumer(o), newPool.getStartDate(), newPool.getEndDate(), 1);
    e1.setId("1");

    Entitlement e2 =
        new Entitlement(
            newPool, TestUtil.createConsumer(o), newPool.getStartDate(), newPool.getEndDate(), 1);
    e2.setId("2");

    newPool.getEntitlements().add(e1);
    newPool.getEntitlements().add(e2);
    return newPool;
  }
Example #26
0
  @Test
  public void testCalculatedValueIsZeroWhenNegativeIsCalculated() {
    consumer.setFact(IS_VIRT, "");
    consumer.setFact(SOCKET_FACT, "4");
    pool.getProduct().setAttribute(SOCKET_ATTRIBUTE, "2");

    Entitlement e = createValidEntitlement(pool);
    e.setQuantity(1000);

    Set<Entitlement> ents = new HashSet<Entitlement>();
    ents.add(e);

    consumer.setEntitlements(ents);

    SuggestedQuantity suggested = quantityRules.getSuggestedQuantity(pool, consumer, new Date());
    assertEquals(new Long(0), suggested.getSuggested());
  }
  private Entitlement mockStackedEntitlement(
      Consumer consumer, String stackId, String productId, String... providedProductIds) {

    Entitlement e = mockEntitlement(consumer, productId, providedProductIds);

    Random gen = new Random();
    int id = gen.nextInt(Integer.MAX_VALUE);
    e.setId(String.valueOf(id));

    Pool p = e.getPool();

    // Setup the attributes for stacking:
    p.addProductAttribute(new ProductPoolAttribute("stacking_id", stackId, productId));
    p.addProductAttribute(new ProductPoolAttribute("sockets", "2", productId));

    return e;
  }
Example #28
0
  private void exportProducts(File baseDir, Consumer consumer) throws IOException {
    File productDir = new File(baseDir.getCanonicalPath(), "products");
    productDir.mkdir();

    Map<String, Product> products = new HashMap<String, Product>();
    for (Entitlement entitlement : consumer.getEntitlements()) {

      for (ProvidedProduct providedProduct : entitlement.getPool().getProvidedProducts()) {
        // Don't want to call the adapter if not needed, it can be expensive.
        if (!products.containsKey(providedProduct.getProductId())) {
          products.put(
              providedProduct.getProductId(),
              productAdapter.getProductById(providedProduct.getProductId()));
        }
      }

      // Don't forget the 'main' product!
      String productId = entitlement.getPool().getProductId();
      if (!products.containsKey(productId)) {
        products.put(productId, productAdapter.getProductById(productId));
      }
    }

    for (Product product : products.values()) {
      String path = productDir.getCanonicalPath();
      String productId = product.getId();
      File file = new File(path, productId + ".json");
      FileWriter writer = new FileWriter(file);
      productExporter.export(mapper, writer, product);
      writer.close();

      // Real products have a numeric id.
      if (StringUtils.isNumeric(product.getId())) {
        ProductCertificate cert = productAdapter.getProductCertificate(product);
        // XXX: not all product adapters implement getProductCertificate,
        // so just skip over this if we get null back
        // XXX: need to decide if the cert should always be in the export, or never.
        if (cert != null) {
          file = new File(productDir.getCanonicalPath(), product.getId() + ".pem");
          writer = new FileWriter(file);
          productCertExporter.export(writer, cert);
          writer.close();
        }
      }
    }
  }
  protected void runPostEntitlement(PoolHelper postHelper, Entitlement entitlement) {
    Pool pool = entitlement.getPool();
    Consumer c = entitlement.getConsumer();

    Map<String, String> attributes = postHelper.getFlattenedAttributes(pool);

    // Perform pool management based on the attributes of the pool:
    // TODO: should really be cleaned up, this used to be post rules but
    // because
    // it actually manages pools we pulled back to engine. Needs re-org.
    if (attributes.containsKey("user_license")) {
      postBindUserLicense(postHelper, pool, c, attributes);
    }

    if (attributes.containsKey("virt_limit")) {
      postBindVirtLimit(postHelper, entitlement, pool, c, attributes);
    }
  }
Example #30
0
  private Pool entitlementPoolWithMembersAndExpiration(
      Owner theOwner,
      Product product,
      final int currentMembers,
      final int maxMembers,
      Date expiry) {
    Pool p = createPoolAndSub(theOwner, product, Long.valueOf(maxMembers), new Date(), expiry);

    for (int i = 0; i < currentMembers; i++) {
      Consumer c = createConsumer(theOwner);
      Entitlement e = createEntitlement(theOwner, c, p, null);
      e.setQuantity(1);
      entitlementCurator.create(e);
      p.getEntitlements().add(e);
      poolCurator.merge(p);
    }
    poolCurator.refresh(p);
    return p;
  }