def test_returns_true_on_success(mock_api_delete):
mock_api_delete.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
response = client.datasets.delete(DATASET_ID)
assert_equal(response, True)
def test_returns_dataset(mock_api_put):
mock_api_put.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
dataset = client.datasets.find_or_create(DATASET_ID, FIELDS)
assert_true(isinstance(dataset, Dataset))
def test_makes_api_call(mock_api_delete):
mock_api_delete.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
client.datasets.delete(DATASET_ID)
mock_api_delete.assert_called_with('/datasets/' + DATASET_ID, API_KEY)
def test_makes_api_call(mock_api_get):
mock_api_get.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
client.ping()
mock_api_get.assert_called_with('/', API_KEY)
def test_returns_true_on_success(mock_api_get):
mock_api_get.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
response = client.ping()
assert_equal(response, True)
def test_returns_true_on_success(mock_api_put):
mock_api_put.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
dataset = client.datasets.find_or_create(DATASET_ID, FIELDS)
response = dataset.put(ITEMS)
assert_equal(response, True)
def test_makes_api_call(mock_api_put):
mock_api_put.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
dataset = client.datasets.find_or_create(DATASET_ID, FIELDS)
dataset.put(ITEMS)
mock_api_put.assert_called_with('/datasets/' + DATASET_ID + '/data',
{'data': ITEMS}, API_KEY)
def test_rethrows_api_error(mock_get_error_message, mock_api_get):
mock_response = Mock(status_code=401)
mock_api_get.return_value = mock_response
mock_get_error_message.return_value = ERROR_MESSAGE
client = geckoboard.client(API_KEY)
try:
client.ping()
except Exception as err:
mock_get_error_message.assert_called_with(mock_response)
assert_equal(err.message, ERROR_MESSAGE)
def test_handles_unique_by(mock_api_put):
mock_api_put.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
client.datasets.find_or_create(DATASET_ID, FIELDS, UNIQUE_BY)
mock_api_put.assert_called_with(
'/datasets/' + DATASET_ID,
{'fields': FIELDS, 'unique_by': UNIQUE_BY},
API_KEY
)
def test_rethrows_api_error(mock_get_error_message, mock_api_put):
mock_response = Mock(status_code=401)
mock_api_put.return_value = mock_response
mock_get_error_message.return_value = ERROR_MESSAGE
client = geckoboard.client(API_KEY)
try:
client.datasets.find_or_create(DATASET_ID, FIELDS)
except Exception as err:
mock_get_error_message.assert_called_with(mock_response)
assert_equal(err.message, ERROR_MESSAGE)
def test_handles_delete_by(mock_api_post, mock_api_put):
mock_api_put.return_value = Mock(status_code=200)
mock_api_post.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
dataset = client.datasets.find_or_create(DATASET_ID, FIELDS)
dataset.post(ITEMS, DELETE_BY)
mock_api_post.assert_called_with('/datasets/' + DATASET_ID + '/data', {
'data': ITEMS,
'delete_by': DELETE_BY
}, API_KEY)
def send_gecko_report(self):
self.count = 0
GECKO_API_TOKEN = settings.GECKO_TOKEN
report = GeskoReport()
try:
gbClient = gb.client(GECKO_API_TOKEN)
gbClient.ping()
self.__push_overview__(gbClient=gbClient, report=report)
self.__push_teams_report__(gbClient=gbClient, report=report)
except Exception as e:
print("GeckoReport Error:{}".format(e))
traceback.print_exc()
def test_rethrows_api_error(mock_get_error_message, mock_api_put):
# Make the initial put pass so we can create the dataset
mock_api_put.return_value = Mock(status_code=200)
client = geckoboard.client(API_KEY)
dataset = client.datasets.find_or_create(DATASET_ID, FIELDS)
# Now make it fail so we can test the error response
mock_response = Mock(status_code=401)
mock_api_put.return_value = mock_response
mock_get_error_message.return_value = ERROR_MESSAGE
try:
dataset.put(ITEMS)
except Exception as err:
mock_get_error_message.assert_called_with(mock_response)
assert_equal(err.message, ERROR_MESSAGE)
def __find_or_create_dataset(self):
gbClient = gb.client(self.GECKO_API_TOKEN)
try:
gbClient.ping()
except:
print("GeckoBoard Failed: Wrong API KEY")
dataset = gbClient.datasets.find_or_create(
'quay.security.scan.by_name', {
'repository': {
'type': 'string',
'name': 'Repository:Tag'
},
'critical': {
'type': 'number',
'name': 'C'
},
'high': {
'type': 'number',
'name': 'H'
},
'medium': {
'type': 'number',
'name': 'M'
}
}, ['repository'])
dataset.put([])
formated_data = []
for repository, vulnerabilitie in (self._report).items():
formated_data.append({
'repository': repository,
'critical': vulnerabilitie['critical'],
'high': vulnerabilitie['high'],
'medium': vulnerabilitie['medium']
})
dataset.put(formated_data)
def finalize_response(self, request, response, *args, **kwargs):
response = super().finalize_response(request, response, *args, **kwargs)
time_started = getattr(self, 'time_started', None)
if time_started:
time_elapsed = datetime.now() - self.time_started
time_elapsed=time_elapsed.total_seconds()*1000
response['supersonic'] = time_elapsed
response['plot'] = request.path
APP_ENV = getattr(settings, "APP_ENV", None)
# print(APP_ENV)
if APP_ENV != "development":
dll=request.path
fora=""
for lin in dll:
if lin=='/':
fora=fora+'_'
else:
fora=fora+lin
# print(fora)
API_KEY = 'ac126939d26650c1f1349b4bc4cab9f2'
client = geckoboard.client(API_KEY)
time_taken=time_elapsed
time_stats=[]
stats={'dura': time_taken}
time_stats.append(stats)
fields={}
fields['dura']={ 'type': 'duration', 'name': 'Time Taken', "time_unit": "milliseconds", 'optional': False }
# print('catalog(%s)stats'% request.path)
dis='catalog%s_stats'% fora
# print(dis)
dataset = client.datasets.find_or_create(dis, fields)
dataset.post(time_stats)
return response
import os
import json
import geckoboard
DATASET_NAME = 'agents.active_groups'
CLIENT = geckoboard.client(os.getenv('GECKO_API_KEY'))
try:
CLIENT.ping()
except:
raise PermissionError('API key invalid.')
def get_schedule(schema):
print(f"Retrieving gecko dataset: {DATASET_NAME}")
return CLIENT.datasets.find_or_create(DATASET_NAME, schema)
def set_schedule(data, schema):
print(f"Setting schedule with data:\n{json.dumps(data,indent=2)}")
schedule = get_schedule(schema)
schedule.put(data)
def delete_schedule():
print(f"Deleting gecko dataset: {DATASET_NAME}")
CLIENT.datasets.delete(DATASET_NAME)
def get_client():
return geckoboard.client(settings.GECKOBOARD_API_KEY)
