def test_no_compliant_until(self, mock_update):
# don't want to munge the module scope version of this because
# setup will load it for later tests
no_compliance_until = copy.deepcopy(SAMPLE_COMPLIANCE_JSON)
no_compliance_until["compliantUntil"] = None
# build and inject a status cache with new values
status_mgr = EntitlementStatusCache()
status_mgr.load_status = Mock(return_value=no_compliance_until)
status_mgr.write_cache = Mock()
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, status_mgr)
self.sorter = CertSorter()
self.sorter.is_registered = Mock(return_value=True)
self.assertTrue(self.sorter.compliant_until is None)
def test_no_compliant_until(self, mock_update):
# don't want to munge the module scope version of this because
# setup will load it for later tests
no_compliance_until = copy.deepcopy(SAMPLE_COMPLIANCE_JSON)
no_compliance_until['compliantUntil'] = None
# build and inject a status cache with new values
status_mgr = EntitlementStatusCache()
status_mgr.load_status = Mock(return_value=no_compliance_until)
status_mgr.write_cache = Mock()
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, status_mgr)
self.sorter = CertSorter()
self.sorter.is_registered = Mock(return_value=True)
self.assertTrue(self.sorter.compliant_until is None)
def setUp(self, mock_update):
SubManFixture.setUp(self)
# Setup mock product and entitlement certs:
self.prod_dir = StubProductDirectory(
pids=[INST_PID_1, INST_PID_2, INST_PID_3, INST_PID_4])
self.ent_dir = StubEntitlementDirectory([
StubEntitlementCertificate(PROD_2, ent_id=ENT_ID_2),
StubEntitlementCertificate(PROD_1, ent_id=ENT_ID_1),
StubEntitlementCertificate(product=PROD_4,
stacking_id=STACK_1,
ent_id=ENT_ID_4),
# entitled, but not installed
StubEntitlementCertificate(StubProduct("not_installed_product",
name="Some Product"),
ent_id="SomeSubId"),
])
self.mock_uep = StubUEP()
self.status_mgr = EntitlementStatusCache()
self.status_mgr.load_status = Mock(return_value=SAMPLE_COMPLIANCE_JSON)
self.status_mgr.write_cache = Mock()
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, self.status_mgr)
inj.provide(inj.PROD_DIR, self.prod_dir)
inj.provide(inj.ENT_DIR, self.ent_dir)
self.sorter = CertSorter()
self.sorter.is_registered = Mock(return_value=True)
def test_write_cache(self):
mock_server_status = {'fake server status': random.uniform(1, 2 ** 32)}
status_cache = EntitlementStatusCache()
status_cache.server_status = mock_server_status
cache_dir = tempfile.mkdtemp()
cache_file = os.path.join(cache_dir, 'status_cache.json')
status_cache.CACHE_FILE = cache_file
status_cache.write_cache()
# try to load the file 5 times, if
# we still can't read it, fail
# we don't know when the write_cache thread ends or
# when it starts. Need to track the cache threads
# but we do not...
tries = 0
while tries <= 5:
try:
new_status_buf = open(cache_file).read()
new_status = json.loads(new_status_buf)
break
except Exception as e:
log.exception(e)
tries += 1
time.sleep(.1)
continue
shutil.rmtree(cache_dir)
self.assertEqual(new_status, mock_server_status)
def test_write_cache(self):
mock_server_status = {'fake server status': random.uniform(1, 2**32)}
status_cache = EntitlementStatusCache()
status_cache.server_status = mock_server_status
cache_dir = tempfile.mkdtemp()
cache_file = os.path.join(cache_dir, 'status_cache.json')
status_cache.CACHE_FILE = cache_file
status_cache.write_cache()
def threadActive(name):
for thread in threading.enumerate():
if thread.getName() == name:
return True
return False
# If the file exists, and the thread that writes it does not, we know writing has completed
while not (os.path.exists(cache_file)
and not threadActive("WriteCacheEntitlementStatusCache")):
pass
try:
new_status_buf = open(cache_file).read()
new_status = json.loads(new_status_buf)
self.assertEquals(new_status, mock_server_status)
finally:
shutil.rmtree(cache_dir)
def test_write_cache(self):
mock_server_status = {'fake server status': random.uniform(1, 2 ** 32)}
status_cache = EntitlementStatusCache()
status_cache.server_status = mock_server_status
cache_dir = tempfile.mkdtemp()
cache_file = os.path.join(cache_dir, 'status_cache.json')
status_cache.CACHE_FILE = cache_file
status_cache.write_cache()
def threadActive(name):
for thread in threading.enumerate():
if thread.getName() == name:
return True
return False
# If the file exists, and the thread that writes it does not, we know writing has completed
while not (os.path.exists(cache_file) and not threadActive("WriteCacheEntitlementStatusCache")):
pass
try:
new_status_buf = open(cache_file).read()
new_status = json.loads(new_status_buf)
self.assertEquals(new_status, mock_server_status)
finally:
shutil.rmtree(cache_dir)
def setUp(self):
super(TestEntitlementStatusCache, self).setUp()
self.status_cache = EntitlementStatusCache()
self.status_cache.write_cache = Mock()
class TestEntitlementStatusCache(SubManFixture):
def setUp(self):
super(TestEntitlementStatusCache, self).setUp()
self.status_cache = EntitlementStatusCache()
self.status_cache.write_cache = Mock()
def test_load_from_server(self):
uep = Mock()
dummy_status = {"a": "1"}
uep.getCompliance = Mock(return_value=dummy_status)
self.status_cache.load_status(uep, "SOMEUUID")
self.assertEqual(dummy_status, self.status_cache.server_status)
self.assertEqual(1, self.status_cache.write_cache.call_count)
def test_load_from_server_on_date_args(self):
uep = Mock()
dummy_status = {"a": "1"}
uep.getCompliance = Mock(return_value=dummy_status)
self.status_cache.load_status(uep, "SOMEUUID", "2199-12-25")
self.assertEqual(dummy_status, self.status_cache.server_status)
self.assertEqual(1, self.status_cache.write_cache.call_count)
def test_load_from_server_on_date_kwargs(self):
uep = Mock()
dummy_status = {"a": "1"}
uep.getCompliance = Mock(return_value=dummy_status)
self.status_cache.load_status(uep, "SOMEUUID", on_date="2199-12-25")
self.assertEqual(dummy_status, self.status_cache.server_status)
self.assertEqual(1, self.status_cache.write_cache.call_count)
def test_server_no_compliance_call(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=RestlibException("boom"))
status = self.status_cache.load_status(uep, "SOMEUUID")
self.assertEqual(None, status)
def test_server_network_error(self):
dummy_status = {"a": "1"}
uep = Mock()
uep.getCompliance = Mock(side_effect=socket.error("boom"))
self.status_cache._cache_exists = Mock(return_value=True)
self.status_cache._read_cache = Mock(return_value=dummy_status)
status = self.status_cache.load_status(uep, "SOMEUUID")
self.assertEqual(dummy_status, status)
self.assertEqual(1, self.status_cache._read_cache.call_count)
# Extremely unlikely but just in case:
def test_server_network_error_no_cache(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=socket.error("boom"))
self.status_cache._cache_exists = Mock(return_value=False)
self.assertEqual(None, self.status_cache.load_status(uep, "SOMEUUID"))
def test_write_cache(self):
mock_server_status = {'fake server status': random.uniform(1, 2 ** 32)}
status_cache = EntitlementStatusCache()
status_cache.server_status = mock_server_status
cache_dir = tempfile.mkdtemp()
cache_file = os.path.join(cache_dir, 'status_cache.json')
status_cache.CACHE_FILE = cache_file
status_cache.write_cache()
# try to load the file 5 times, if
# we still can't read it, fail
# we don't know when the write_cache thread ends or
# when it starts. Need to track the cache threads
# but we do not...
tries = 0
while tries <= 5:
try:
new_status_buf = open(cache_file).read()
new_status = json.loads(new_status_buf)
break
except Exception as e:
log.exception(e)
tries += 1
time.sleep(.1)
continue
shutil.rmtree(cache_dir)
self.assertEqual(new_status, mock_server_status)
def test_unauthorized_exception_handled(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=UnauthorizedException(401, "GET"))
self.assertEqual(None, self.status_cache.load_status(uep, "aaa"))
class TestEntitlementStatusCache(SubManFixture):
def setUp(self):
super(TestEntitlementStatusCache, self).setUp()
self.status_cache = EntitlementStatusCache()
self.status_cache.write_cache = Mock()
def test_load_from_server(self):
uep = Mock()
dummy_status = {"a": "1"}
uep.getCompliance = Mock(return_value=dummy_status)
self.status_cache.load_status(uep, "SOMEUUID")
self.assertEquals(dummy_status, self.status_cache.server_status)
self.assertEquals(1, self.status_cache.write_cache.call_count)
def test_server_no_compliance_call(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=RestlibException("boom"))
status = self.status_cache.load_status(uep, "SOMEUUID")
self.assertEquals(None, status)
def test_server_network_error(self):
dummy_status = {"a": "1"}
uep = Mock()
uep.getCompliance = Mock(side_effect=socket.error("boom"))
self.status_cache._cache_exists = Mock(return_value=True)
self.status_cache._read_cache = Mock(return_value=dummy_status)
status = self.status_cache.load_status(uep, "SOMEUUID")
self.assertEquals(dummy_status, status)
self.assertEquals(1, self.status_cache._read_cache.call_count)
# Extremely unlikely but just in case:
def test_server_network_error_no_cache(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=socket.error("boom"))
self.status_cache._cache_exists = Mock(return_value=False)
self.assertEquals(None, self.status_cache.load_status(uep, "SOMEUUID"))
def test_write_cache(self):
mock_server_status = {'fake server status': random.uniform(1, 2 ** 32)}
status_cache = EntitlementStatusCache()
status_cache.server_status = mock_server_status
cache_dir = tempfile.mkdtemp()
cache_file = os.path.join(cache_dir, 'status_cache.json')
status_cache.CACHE_FILE = cache_file
status_cache.write_cache()
def threadActive(name):
for thread in threading.enumerate():
if thread.getName() == name:
return True
return False
# If the file exists, and the thread that writes it does not, we know writing has completed
while not (os.path.exists(cache_file) and not threadActive("WriteCacheEntitlementStatusCache")):
pass
try:
new_status_buf = open(cache_file).read()
new_status = json.loads(new_status_buf)
self.assertEquals(new_status, mock_server_status)
finally:
shutil.rmtree(cache_dir)
def test_unauthorized_exception_handled(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=UnauthorizedException(401, "GET"))
self.assertEquals(None, self.status_cache.load_status(uep, "aaa"))
class TestEntitlementStatusCache(SubManFixture):
def setUp(self):
super(TestEntitlementStatusCache, self).setUp()
self.status_cache = EntitlementStatusCache()
self.status_cache.write_cache = Mock()
def test_load_from_server(self):
uep = Mock()
dummy_status = {"a": "1"}
uep.getCompliance = Mock(return_value=dummy_status)
self.status_cache.load_status(uep, "SOMEUUID")
self.assertEquals(dummy_status, self.status_cache.server_status)
self.assertEquals(1, self.status_cache.write_cache.call_count)
def test_server_no_compliance_call(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=RestlibException("boom"))
status = self.status_cache.load_status(uep, "SOMEUUID")
self.assertEquals(None, status)
def test_server_network_error(self):
dummy_status = {"a": "1"}
uep = Mock()
uep.getCompliance = Mock(side_effect=socket.error("boom"))
self.status_cache._cache_exists = Mock(return_value=True)
self.status_cache._read_cache = Mock(return_value=dummy_status)
status = self.status_cache.load_status(uep, "SOMEUUID")
self.assertEquals(dummy_status, status)
self.assertEquals(1, self.status_cache._read_cache.call_count)
# Extremely unlikely but just in case:
def test_server_network_error_no_cache(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=socket.error("boom"))
self.status_cache._cache_exists = Mock(return_value=False)
self.assertEquals(None, self.status_cache.load_status(uep, "SOMEUUID"))
def test_write_cache(self):
mock_server_status = {'fake server status': random.uniform(1, 2**32)}
status_cache = EntitlementStatusCache()
status_cache.server_status = mock_server_status
cache_dir = tempfile.mkdtemp()
cache_file = os.path.join(cache_dir, 'status_cache.json')
status_cache.CACHE_FILE = cache_file
status_cache.write_cache()
def threadActive(name):
for thread in threading.enumerate():
if thread.getName() == name:
return True
return False
# If the file exists, and the thread that writes it does not, we know writing has completed
while not (os.path.exists(cache_file)
and not threadActive("WriteCacheEntitlementStatusCache")):
pass
try:
new_status_buf = open(cache_file).read()
new_status = json.loads(new_status_buf)
self.assertEquals(new_status, mock_server_status)
finally:
shutil.rmtree(cache_dir)
def test_unauthorized_exception_handled(self):
uep = Mock()
uep.getCompliance = Mock(side_effect=UnauthorizedException(401, "GET"))
self.assertEquals(None, self.status_cache.load_status(uep, "aaa"))
