def setUp(self):
super(RepoUpdateActionTests, self).setUp()
stub_prod = StubProduct("fauxprod", provided_tags="TAG1,TAG2")
stub_prod2 = StubProduct("fauxprovidedprod", provided_tags="TAG4")
stub_prod_cert = StubProductCertificate(stub_prod,
provided_products=[stub_prod2])
stub_prod2 = StubProduct("fauxprod2", provided_tags="TAG5,TAG6")
stub_prod2_cert = StubProductCertificate(stub_prod2)
prod_dir = StubProductDirectory([stub_prod_cert, stub_prod2_cert])
inj.provide(inj.PROD_DIR, prod_dir)
stub_content = [
StubContent("c1", required_tags="", gpg=None), # no required tags
StubContent("c2", required_tags="TAG1", gpg=""),
StubContent("c3",
required_tags="TAG1,TAG2,TAG3"), # should get skipped
StubContent("c4",
required_tags="TAG1,TAG2,TAG4,TAG5,TAG6",
gpg="/gpg.key",
url="/$some/$path"),
StubContent("c5", content_type="file", required_tags="", gpg=None),
StubContent("c6", content_type="file", required_tags="", gpg=None),
]
self.stub_ent_cert = StubEntitlementCertificate(stub_prod,
content=stub_content)
ent_dir = StubEntitlementDirectory([self.stub_ent_cert])
inj.provide(inj.ENT_DIR, ent_dir)
repolib.ConsumerIdentity = StubConsumerIdentity
def setUp(self):
stub_prod = StubProduct("fauxprod", provided_tags="TAG1,TAG2")
stub_prod2 = StubProduct("fauxprovidedprod", provided_tags="TAG4")
stub_prod_cert = StubProductCertificate(stub_prod,
provided_products=[stub_prod2])
stub_prod2 = StubProduct("fauxprod2", provided_tags="TAG5,TAG6")
stub_prod2_cert = StubProductCertificate(stub_prod2)
stub_prod_dir = StubProductDirectory([stub_prod_cert, stub_prod2_cert])
stub_content = [
StubContent("c1", required_tags="", gpg=None), # no required tags
StubContent("c2", required_tags="TAG1", gpg=""),
StubContent("c3",
required_tags="TAG1,TAG2,TAG3"), # should get skipped
StubContent("c4",
required_tags="TAG1,TAG2,TAG4,TAG5,TAG6",
gpg="/gpg.key",
url="/$some/$path"),
StubContent("c5", content_type="file", required_tags="", gpg=None),
StubContent("c6", content_type="file", required_tags="", gpg=None),
]
self.stub_ent_cert = StubEntitlementCertificate(stub_prod,
content=stub_content)
stub_ent_dir = StubCertificateDirectory([self.stub_ent_cert])
repolib.ConsumerIdentity = stubs.StubConsumerIdentity
stub_uep = stubs.StubUEP()
self.update_action = UpdateAction(prod_dir=stub_prod_dir,
ent_dir=stub_ent_dir,
uep=stub_uep)
def setUp(self):
# Setup mock product and entitlement certs:
self.prod_dir = StubCertificateDirectory([
# Will be unentitled:
StubProductCertificate(StubProduct(INST_PID_1)),
# Will be entitled:
StubProductCertificate(StubProduct(INST_PID_2)),
# Will be entitled but expired:
StubProductCertificate(StubProduct(INST_PID_3)),
])
self.ent_dir = StubEntitlementDirectory([
StubEntitlementCertificate(StubProduct(INST_PID_2)),
StubEntitlementCertificate(
StubProduct(INST_PID_3),
start_date=datetime.now() - timedelta(days=365),
end_date=datetime.now() - timedelta(days=2)),
StubEntitlementCertificate(
StubProduct(INST_PID_4),
start_date=datetime.now() - timedelta(days=365),
end_date=datetime.now() + timedelta(days=365)),
StubEntitlementCertificate(StubProduct(INST_PID_5)),
# entitled, but not installed
StubEntitlementCertificate(StubProduct('not_installed_product')),
])
def setUp(self):
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A")),
StubProductCertificate(StubProduct('b-product', name="Product B")),
StubProductCertificate(StubProduct('c-product', name="Product C")),
])
self.mgr = InstalledProductsManager(self.prod_dir)
def setUp(self):
super(TestInstalledProductsCache, self).setUp()
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A")),
StubProductCertificate(StubProduct('b-product', name="Product B")),
StubProductCertificate(StubProduct('c-product', name="Product C")),
])
inj.provide(inj.PROD_DIR, self.prod_dir)
self.mgr = InstalledProductsManager()
def test_default_products_matching_ids(self, MockExists):
MockExists.return_value = True
pd = ProductDirectory()
top_product = StubProduct("top")
default_product = StubProduct("top")
pd.installed_prod_dir.list = lambda: [StubProductCertificate(top_product, [])]
pd.default_prod_dir.list = lambda: [StubProductCertificate(default_product, [])]
results = pd.list()
self.assertEquals(1, len(results))
resulting_ids = [cert.products[0].id for cert in results]
self.assertTrue("top" in resulting_ids)
def test_partial_and_invalid_fact(self, mock_sorter):
ents = []
stub_product = StubProduct('1005')
stub_ent_cert = StubEntitlementCertificate(stub_product, quantity=2, stacking_id='stack1', sockets=2)
ents.append(stub_ent_cert)
entitlement_directory = StubCertificateDirectory(ents)
product = StubProduct("product1")
product_directory = StubCertificateDirectory([
StubProductCertificate(product)])
mock_sorter_instance = mock_sorter.return_value
mock_sorter_instance.partially_valid_products = {'foo': 'blah'}
mock_sorter_instance.unentitled_products = {'bar': 'apple'}
mock_sorter_instance.expired_products = {}
mock_sorter_instance.partial_stacks = {}
facts = Facts(None)
facts.product_dir = product_directory
facts.entitlement_dir = entitlement_directory
facts_dict = facts.get_facts()
self.assertEquals("invalid", facts_dict['system.entitlements_valid'])
def test_future_entitled_products(self):
cert = StubProductCertificate(StubProduct('product1'))
product_dir = StubCertificateDirectory([cert])
cert1 = StubEntitlementCertificate(StubProduct('product1'),
start_date=datetime(2010,
1,
1,
tzinfo=GMT()),
end_date=datetime(2050,
1,
1,
tzinfo=GMT()))
cert2 = StubEntitlementCertificate(StubProduct('product1'),
start_date=datetime(2049,
1,
1,
tzinfo=GMT()),
end_date=datetime(2070,
1,
1,
tzinfo=GMT()))
ent_dir = StubCertificateDirectory([cert1, cert2])
last_valid_date = find_first_invalid_date(ent_dir=ent_dir,
product_dir=product_dir,
facts_dict={})
self.assertEqual(2070, last_valid_date.year)
self.assertEqual(1, last_valid_date.month)
self.assertEqual(2, last_valid_date.day)
def test_filter_no_overlap_with_future_entitlement(self):
product1 = "Test Product 1"
provided1 = "Provided By Test Product 1"
cert_start = datetime.now() + timedelta(days=365)
cert_end = cert_start + timedelta(days=365)
cert1 = StubProductCertificate(StubProduct(provided1),
start_date=cert_start,
end_date=cert_end)
ent_dir = StubCertificateDirectory([cert1])
pool_filter = PoolFilter(product_dir=StubCertificateDirectory([]),
entitlement_dir=ent_dir)
begin_date = datetime.now() - timedelta(days=100)
end_date = datetime.now() + timedelta(days=100)
pools = [
create_pool(product1,
product1,
provided_products=[provided1],
start_end_range=DateRange(begin_date, end_date)),
]
result = pool_filter.filter_out_overlapping(pools)
self.assertEquals(1, len(result))
result = pool_filter.filter_out_non_overlapping(pools)
self.assertEquals(0, len(result))
def _stub_content(self, include_content_access=False):
stub_prod = StubProduct('stub_product', provided_tags="stub-product")
stub_content = StubContent("a_test_repo", required_tags="stub-product")
stub_content2 = StubContent("test_repo_2",
required_tags="stub-product")
stub_ent_cert = StubEntitlementCertificate(stub_prod,
content=[stub_content])
stub_prod_cert = StubProductCertificate(stub_prod)
certs = [stub_ent_cert]
if include_content_access:
self.stub_content_access_cert = StubEntitlementCertificate(
stub_prod,
content=[stub_content, stub_content2],
entitlement_type=CONTENT_ACCESS_CERT_TYPE)
# content access cert is first and last, so naively wrong implementations will prioritize it.
certs = [
self.stub_content_access_cert, stub_ent_cert,
self.stub_content_access_cert
]
stub_ent_dir = StubEntitlementDirectory(certs)
stub_prod_dir = StubProductDirectory([stub_prod_cert])
inj.provide(inj.ENT_DIR, stub_ent_dir)
inj.provide(inj.PROD_DIR, stub_prod_dir)
def test_all_expired_entitlements(self):
cert = StubProductCertificate(StubProduct('product1'))
product_dir = StubCertificateDirectory([cert])
cert1 = StubEntitlementCertificate(StubProduct('product1'),
start_date=datetime(2000,
1,
1,
tzinfo=GMT()),
end_date=datetime(2001,
1,
1,
tzinfo=GMT()))
cert2 = StubEntitlementCertificate(StubProduct('product1'),
start_date=datetime(2000,
12,
1,
tzinfo=GMT()),
end_date=datetime(2005,
1,
1,
tzinfo=GMT()))
ent_dir = StubCertificateDirectory([cert1, cert2])
# Because all entitlements have expired, we should get back the current
# date as the last date of valid entitlements:
today = datetime.now(GMT())
last_valid_date = find_first_invalid_date(ent_dir=ent_dir,
product_dir=product_dir,
facts_dict={})
self.assertEqual(today.year, last_valid_date.year)
self.assertEqual(today.month, last_valid_date.month)
self.assertEqual(today.day, last_valid_date.day)
def test_get_installed_products(self, MockExists):
MockExists.return_value = True
pd = ProductDirectory()
top_product = StubProduct("top")
provided_products = [StubProduct("provided")]
pd.list = lambda: [StubProductCertificate(top_product, provided_products)]
installed_products = pd.get_installed_products()
self.assertTrue("top" in installed_products)
def test_installed_filter_multi_match(self):
product1 = 'product1'
product2 = 'product2'
provided = 'providedProduct'
pd = StubCertificateDirectory([
StubProductCertificate(StubProduct(provided)),
StubProductCertificate(StubProduct(product2))
])
pool_filter = PoolFilter(product_dir=pd,
entitlement_dir=StubCertificateDirectory([]))
pools = [
create_pool(product1, product1),
create_pool(product2, product2, provided_products=[provided]),
]
result = pool_filter.filter_out_installed(pools)
self.assertEquals(1, len(result))
self.assertEquals(product1, result[0]['productId'])
def test_no_entitlement_for_installed_product_shows_invalid(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory([
StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([])
facts = Facts(None)
facts.product_dir = product_directory
facts.entitlement_dir = entitlement_directory
facts_dict = facts.get_facts()
self.assertEquals("invalid", facts_dict['system.entitlements_valid'])
def test_no_entitlement_for_installed_product_shows_no_subscribed(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory(
[StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([])
product_status = getInstalledProductStatus(product_directory,
entitlement_directory)
self.assertEquals(1, len(product_status))
self.assertEquals("not_subscribed", product_status[0][4])
def test_future_dated_entitlement_shows_invalid(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory([
StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([
StubEntitlementCertificate(product,
start_date=(datetime.now() + timedelta(days=1365)))])
facts = Facts(None)
facts.product_dir = product_directory
facts.entitlement_dir = entitlement_directory
facts_dict = facts.get_facts()
self.assertEquals("invalid", facts_dict['system.entitlements_valid'])
def test_one_product_with_two_entitlements_lists_product_twice(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory(
[StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([
StubEntitlementCertificate(product),
StubEntitlementCertificate(product)
])
product_status = getInstalledProductStatus(product_directory,
entitlement_directory)
# only "product" is installed
self.assertEquals(1, len(product_status))
def test_future_dated_entitlement_shows_future_subscribed(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory(
[StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([
StubEntitlementCertificate(product,
start_date=(datetime.now() +
timedelta(days=1365)))
])
product_status = getInstalledProductStatus(product_directory,
entitlement_directory)
self.assertEquals(1, len(product_status))
self.assertEquals("future_subscribed", product_status[0][4])
def _stub_content(self):
stub_prod = StubProduct('stub_product', provided_tags="stub-product")
stub_content = StubContent("a_test_repo", required_tags="stub-product")
stub_ent_cert = StubEntitlementCertificate(stub_prod,
content=[stub_content])
stub_prod_cert = StubProductCertificate(stub_prod)
stub_ent_dir = StubEntitlementDirectory([stub_ent_cert])
stub_prod_dir = StubProductDirectory([stub_prod_cert])
inj.provide(inj.ENT_DIR, stub_ent_dir)
inj.provide(inj.PROD_DIR, stub_prod_dir)
def test_expired_entitlement_for_installed_product_shows_expired(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory(
[StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([
StubEntitlementCertificate(product,
end_date=(datetime.now() -
timedelta(days=2)))
])
product_status = getInstalledProductStatus(product_directory,
entitlement_directory)
self.assertEquals(1, len(product_status))
self.assertEquals("expired", product_status[0][4])
def test_entitled_products(self):
cert = StubProductCertificate(StubProduct('product1'))
prod_dir = StubCertificateDirectory([cert])
cert1 = StubEntitlementCertificate(
StubProduct('product1'), start_date=datetime(2010, 1, 1),
end_date=datetime(2050, 1, 1))
cert2 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime(2010, 1, 1),
end_date=datetime(2060, 1, 1))
ent_dir = StubCertificateDirectory([cert1, cert2])
last_valid_date = find_first_invalid_date(ent_dir, prod_dir, {})
self.assertEqual(2050, last_valid_date.year)
def test_one_subscription_with_bundled_products_lists_once_part_two(self):
product1 = StubProduct("product1")
product2 = StubProduct("product2")
product3 = StubProduct("product3")
product_directory = StubCertificateDirectory([
StubProductCertificate(product1),
StubProductCertificate(product2)
])
entitlement_directory = StubCertificateDirectory([
StubEntitlementCertificate(product1, [product2, product3],
sockets=10)
])
product_status = getInstalledProductStatus(product_directory,
entitlement_directory)
# product3 isn't installed
self.assertEquals(2, len(product_status))
#self.assertEquals("product3", product_status[0][0])
#self.assertEquals("Not Installed", product_status[0][3])
self.assertEquals("product2", product_status[0][0])
self.assertEquals("subscribed", product_status[0][4])
self.assertEquals("product1", product_status[1][0])
self.assertEquals("subscribed", product_status[1][4])
def test_match(self):
prod_cert = StubProductCertificate(
product=StubProduct(name="test*product?", product_id="123456789"))
test_data = [
(None, prod_cert, False),
("", prod_cert, False),
("test", prod_cert, False),
("product", prod_cert, False),
("test\*product\?", prod_cert, True),
("test*", prod_cert, True),
("test*********", prod_cert, True),
("test?????????", prod_cert, True),
("*product?", prod_cert, True),
("*product\?", prod_cert, True),
("?????product*", prod_cert, True),
("*****product*", prod_cert, True),
("?????????????", prod_cert, True),
("*************", prod_cert, True),
("??**??*??**??", prod_cert, True),
("**??**?**??**", prod_cert, True),
("test?product\?", prod_cert, True),
("test*product?", prod_cert, True),
("test*nope", prod_cert, False),
("nope*product", prod_cert, False),
("*nope*", prod_cert, False),
("test*nope*product", prod_cert, False),
("1234*", prod_cert, True),
("*4567*", prod_cert, True),
("123???789", prod_cert, True),
("??34567??", prod_cert, True),
("*4?6*", prod_cert, True),
("1234", prod_cert, False),
("??123456789", prod_cert, False),
]
for (index, data) in enumerate(test_data):
cert_filter = ProductCertificateFilter(filter_string=data[0])
result = cert_filter.match(data[1])
self.assertEquals(
result, data[2],
"ProductCertificateFilter.match failed with data set %i.\nActual: %s\nExpected: %s"
% (index, result, data[2]))
def test_currently_unentitled_products(self):
cert = StubProductCertificate(StubProduct('unentitledProduct'))
prod_dir = StubCertificateDirectory([cert])
cert1 = StubEntitlementCertificate(
StubProduct('product1'), start_date=datetime(2010, 1, 1),
end_date=datetime(2050, 1, 1))
cert2 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime(2010, 1, 1),
end_date=datetime(2060, 1, 1))
ent_dir = StubCertificateDirectory([cert1, cert2])
# Because we have an unentitled product, we should get back the current
# date as the last date of valid entitlements:
today = datetime.now(GMT())
last_valid_date = find_first_invalid_date(ent_dir, prod_dir, {})
self.assertEqual(today.year, last_valid_date.year)
self.assertEqual(today.month, last_valid_date.month)
self.assertEqual(today.day, last_valid_date.day)
def create_prod_cert(pid):
return StubProductCertificate(StubProduct(pid))
def stub_prod_cert(pid):
return StubProductCertificate(StubProduct(pid))