def test_read_json_files(self):
"""Testing method or function named read_json_files."""
# Initializing key variables
dict_1 = {
'key1': 1,
'key2': 2,
'key3': 3,
'key4': 4,
}
dict_2 = {
'key6': 6,
'key7': 7,
}
# Create a temporary file without a json extension and test
directory = tempfile.mkdtemp()
with self.assertRaises(SystemExit):
_ = files.read_json_files(directory)
os.removedirs(directory)
# Create a temporary file without a json extension and test
directory = tempfile.mkdtemp()
with self.assertRaises(SystemExit):
_ = files.read_json_files(directory, die=True)
os.removedirs(directory)
# Test with die being False. Nothing should happen
directory = tempfile.mkdtemp()
_ = files.read_json_files(directory, die=False)
os.removedirs(directory)
# Create temp file with known data
directory = tempfile.mkdtemp()
filenames = {
'{}{}file_1.json'.format(directory, os.sep): dict_1,
'{}{}file_2.json'.format(directory, os.sep): dict_2
}
for filename, data_dict in filenames.items():
with open(filename, 'w') as filehandle:
json.dump(data_dict, filehandle)
# Get Results
result = files.read_json_files(directory)
# First test, only 2 files
self.assertEqual(len(result), 2)
# Clean up
for filepath, data in result:
self.assertEqual(filepath in filenames, True)
for key, value in sorted(data.items()):
self.assertEqual(filenames[filepath][key], value)
os.remove(filepath)
os.removedirs(directory)
def test_encrypted_post(self):
"""Test that the API can receive and decrypt
encrypted data from agent"""
# Initialize key variables
config = ServerConfig()
agent_name = 'test_encrypted_agent'
# Create a directory for the Agent keyring as by default the
# API and agent use the same keyring directory
keyring_directory = tempfile.mkdtemp()
# Make agent data
agent_data = _make_agent_data()
# Turn agent data into a dict to be compared to
# the data received by the API
expected = converter.posting_data_points(
converter.agentdata_to_post(agent_data))
# Make encrypted post
encrypted_agent = EncryptedAgent(agent_name,
directory=keyring_directory)
post_encrypted = EncryptedPostAgent(agent_data,
encrypted_agent.encryption)
post_encrypted.post()
# Read data from directory
cache_directory = config.agent_cache_directory(PATTOO_API_AGENT_NAME)
cache_data = files.read_json_files(cache_directory)
# Test
self.assertEqual(len(cache_data), 1)
self.assertEqual(len(cache_data[0]), 2)
result = cache_data[0][1]
# Result and expected are not quite the same. 'expected' will have
# lists of tuples where 'result' will have lists of lists
for key, value in result.items():
if key not in ['pattoo_agent_timestamp', 'pattoo_datapoints']:
self.assertEqual(value, expected[key])
self.assertEqual(result['pattoo_datapoints']['datapoint_pairs'],
expected['pattoo_datapoints']['datapoint_pairs'])
# Test list of tuples
for key, value in result['pattoo_datapoints']['key_value_pairs'].items(
):
self.assertEqual(
tuple(value),
expected['pattoo_datapoints']['key_value_pairs'][int(key)])
# Revert cache_directory
for filename in os.listdir(cache_directory):
# Examine all the '.json' files in directory
if filename.endswith('.json'):
# Read file and add to string
filepath = '{}{}{}'.format(cache_directory, os.sep, filename)
os.remove(filepath)
def test_encrypted_post(self):
"""Test that the API can receive and decrypt
encrypted data from agent"""
# Initialize key variables
config = ServerConfig()
# Get Pgpier object
gconfig = Config() # Get config for Pgpier
# Create Pgpier object for the agent
agent_gpg = files.set_gnupg("test_encrypted_agent", gconfig,
"*****@*****.**")
# Make agent data
agent_data = _make_agent_data()
# Turn agent data into a dict to be compared to
# the data received by the API
expected = converter.posting_data_points(
converter.agentdata_to_post(agent_data))
# Make encrypted post
post_encrypted = EncryptedPostAgent(agent_data, agent_gpg)
post_encrypted.post()
# Read data from directory
cache_directory = config.agent_cache_directory(PATTOO_API_AGENT_NAME)
cache_data = files.read_json_files(cache_directory)
# Test
self.assertEqual(len(cache_data), 1)
self.assertEqual(len(cache_data[0]), 2)
result = cache_data[0][1]
# Result and expected are not quite the same. 'expected' will have
# lists of tuples where 'result' will have lists of lists
for key, value in result.items():
if key != 'pattoo_datapoints':
self.assertEqual(value, expected[key])
self.assertEqual(result['pattoo_datapoints']['datapoint_pairs'],
expected['pattoo_datapoints']['datapoint_pairs'])
# Test list of tuples
for key, value in result['pattoo_datapoints']['key_value_pairs'].items(
):
self.assertEqual(
tuple(value),
expected['pattoo_datapoints']['key_value_pairs'][int(key)])
# Revert cache_directory
for filename in os.listdir(cache_directory):
# Examine all the '.json' files in directory
if filename.endswith('.json'):
# Read file and add to string
filepath = '{}{}{}'.format(cache_directory, os.sep, filename)
os.remove(filepath)
def test_purge(self):
"""Testing method / function purge."""
# Initialize key variables
config = ServerConfig()
cache_directory = config.agent_cache_directory(PATTOO_API_AGENT_NAME)
# Initialize key variables
_ = create_cache()
# Test
result = files.read_json_files(cache_directory)
self.assertTrue(bool(result))
# Test - Purge
cache = Cache()
cache.purge()
# Test
result = files.read_json_files(cache_directory, die=False)
self.assertFalse(bool(result))
def test_receive(self):
"""Testing method / function receive."""
# Initialize key variables
config = ServerConfig()
apd = _create_apd()
expected = converter.posting_data_points(
converter.agentdata_to_post(apd))
# Post data
post = PostAgent(apd)
post.post()
# Read data from directory
cache_directory = config.agent_cache_directory(PATTOO_API_AGENT_NAME)
cache_data = files.read_json_files(cache_directory)
# Test
self.assertEqual(len(cache_data), 1)
self.assertEqual(len(cache_data[0]), 2)
result = cache_data[0][1]
# Result and expected are not quite the same. 'expected' will have
# lists of tuples where 'result' will have lists of lists
for key, value in result.items():
if key != 'pattoo_datapoints':
self.assertEqual(value, expected[key])
self.assertEqual(
result['pattoo_datapoints']['datapoint_pairs'],
expected['pattoo_datapoints']['datapoint_pairs'])
# Test list of tuples
for key, value in result[
'pattoo_datapoints']['key_value_pairs'].items():
self.assertEqual(
tuple(value),
expected['pattoo_datapoints']['key_value_pairs'][int(key)])
# Revert cache_directory
for filename in os.listdir(cache_directory):
# Examine all the '.json' files in directory
if filename.endswith('.json'):
# Read file and add to string
filepath = '{}{}{}'.format(cache_directory, os.sep, filename)
os.remove(filepath)
def __init__(self, batch_size=500, age=0):
"""Initialize the class.
Args:
batch_size: Number of files to read
age: Minimum age of files to be read per batch
Returns:
None
"""
# Get cache directory
config = Config()
directory = config.agent_cache_directory(PATTOO_API_AGENT_NAME)
self._batch_id = int(time.time() * 1000)
# Read data from cache. Stop if there is no data found.
self._data = files.read_json_files(directory,
die=False,
age=age,
count=batch_size)
# Save the number of files read
self.files = len(self._data)
