From 974427aa6979dfef70de61b59a051652931649d4 Mon Sep 17 00:00:00 2001 From: Manali Latkar Date: Thu, 18 Jul 2013 15:58:18 +0530 Subject: [PATCH] Added stacky server api methods show, do_uuid, search and show --- stacktach/models.py | 40 ++++- stacktach/stacky_server.py | 142 ++++++++++++++---- stacktach/tests.py | 83 +++++++++++ stacktach/urls.py | 9 +- tests/unit/test_stacky_server.py | 242 +++++++++++++++++++++++++++++-- 5 files changed, 471 insertions(+), 45 deletions(-) diff --git a/stacktach/models.py b/stacktach/models.py index 5e233bd..410b2a6 100644 --- a/stacktach/models.py +++ b/stacktach/models.py @@ -13,10 +13,15 @@ # License for the specific language governing permissions and limitations # under the License. -from django import forms +import copy from django.db import models +def routing_key_type(key): + if key.endswith('error'): + return 'E' + return ' ' + class Deployment(models.Model): name = models.CharField(max_length=50) @@ -25,6 +30,8 @@ class Deployment(models.Model): class GenericRawData(models.Model): + result_titles = [["#", "?", "When", "Deployment", "Event", "Host", + "Instance", "Request id"]] deployment = models.ForeignKey(Deployment) tenant = models.CharField(max_length=50, null=True, blank=True, db_index=True) @@ -52,8 +59,17 @@ class GenericRawData(models.Model): def get_name(): return GenericRawData.__name__ + def search_results(self, results, when, routing_key_status): + if not results: + results = copy.deepcopy(self.result_titles) + results.append([self.id, routing_key_status, str(when), + self.deployment.name, self.event, self.host, + self.instance, self.request_id]) + return results class RawData(models.Model): + result_titles = [["#", "?", "When", "Deployment", "Event", "Host", + "State", "State'", "Task'"]] deployment = models.ForeignKey(Deployment) tenant = models.CharField(max_length=50, null=True, blank=True, db_index=True) @@ -87,10 +103,22 @@ class RawData(models.Model): def __repr__(self): return "%s %s %s" % (self.event, self.instance, self.state) + @property + def uuid(self): + return self.instance + @staticmethod def get_name(): return RawData.__name__ + def search_results(self, results, when, routing_key_status): + if not results: + results = copy.deepcopy(self.result_titles) + results.append([self.id, routing_key_status, str(when), + self.deployment.name, self.event, self.host, self.state, + self.old_state, self.old_task]) + return results + class RawDataImageMeta(models.Model): raw = models.ForeignKey(RawData, null=False) @@ -273,6 +301,8 @@ class JsonReport(models.Model): class GlanceRawData(models.Model): + result_titles = [["#", "?", "When", "Deployment", "Event", "Host", + "Status"]] ACTIVE = 'active' DELETED = 'deleted' KILLED = 'killed' @@ -317,6 +347,14 @@ class GlanceRawData(models.Model): def get_name(): return GlanceRawData.__name__ + def search_results(self, results, when, routing_key_status): + if not results: + results = copy.deepcopy(self.result_titles) + results.append([self.id, routing_key_status, str(when), + self.deployment.name, self.event, self.host, + self.status]) + return results + class ImageUsage(models.Model): uuid = models.CharField(max_length=50, db_index=True) diff --git a/stacktach/stacky_server.py b/stacktach/stacky_server.py index f42116c..70c732e 100644 --- a/stacktach/stacky_server.py +++ b/stacktach/stacky_server.py @@ -9,13 +9,14 @@ from django.shortcuts import get_object_or_404 import datetime_to_decimal as dt import models import utils +from django.core.exceptions import ObjectDoesNotExist, FieldError SECS_PER_HOUR = 60 * 60 SECS_PER_DAY = SECS_PER_HOUR * 24 -def get_event_names(): - return models.RawData.objects.values('event').distinct() +def get_event_names(service='nova'): + return _model_factory(service).values('event').distinct() def get_host_names(): @@ -104,22 +105,25 @@ def do_hosts(request): return rsp(json.dumps(results)) -def do_uuid(request): +def do_uuid(request, service='nova'): uuid = str(request.GET['uuid']) if not utils.is_uuid_like(uuid): msg = "%s is not uuid-like" % uuid return error_response(400, 'Bad Request', msg) + model = _model_factory(service) + result = {} + param = {} + if service == 'nova' or service == 'generic': + param = {'instance': uuid} + if service == 'glance': + param = {'uuid': uuid} - related = models.RawData.objects.select_related().filter(instance=uuid)\ - .order_by('when') - results = [["#", "?", "When", "Deployment", "Event", "Host", "State", - "State'", "Task'"]] - for e in related: - when = dt.dt_from_decimal(e.when) - results.append([e.id, routing_key_type(e.routing_key), str(when), - e.deployment.name, e.event, e.host, e.state, - e.old_state, e.old_task]) - return rsp(json.dumps(results)) + related = model.select_related().filter(**param).order_by('when') + for event in related: + when = dt.dt_from_decimal(event.when) + routing_key_status = routing_key_type(event.routing_key) + result = event.search_results(result, when, routing_key_status) + return rsp(json.dumps(result)) def do_timings_uuid(request): @@ -202,15 +206,7 @@ def do_request(request): return rsp(json.dumps(results)) -def do_show(request, event_id): - event_id = int(event_id) - results = [] - event = None - try: - event = models.RawData.objects.get(id=event_id) - except models.RawData.ObjectDoesNotExist: - return results - +def append_nova_raw_attributes(event, results): results.append(["Key", "Value"]) results.append(["#", event.id]) when = dt.dt_from_decimal(event.when) @@ -224,16 +220,77 @@ def do_show(request, event_id): results.append(["Host", event.host]) results.append(["UUID", event.instance]) results.append(["Req ID", event.request_id]) - - final = [results, ] - j = json.loads(event.json) - final.append(json.dumps(j, indent=2)) - final.append(event.instance) - - return rsp(json.dumps(final)) + return results -def do_watch(request, deployment_id): +def append_glance_raw_attributes(event, results): + results.append(["Key", "Value"]) + results.append(["#", event.id]) + when = dt.dt_from_decimal(event.when) + results.append(["When", str(when)]) + results.append(["Deployment", event.deployment.name]) + results.append(["Category", event.routing_key]) + results.append(["Publisher", event.publisher]) + results.append(["Status", event.status]) + results.append(["Event", event.event]) + results.append(["Service", event.service]) + results.append(["Host", event.host]) + results.append(["UUID", event.uuid]) + results.append(["Req ID", event.request_id]) + return results + + +def append_generic_raw_attributes(event, results): + results.append(["Key", "Value"]) + results.append(["#", event.id]) + when = dt.dt_from_decimal(event.when) + results.append(["When", str(when)]) + results.append(["Deployment", event.deployment.name]) + results.append(["Category", event.routing_key]) + results.append(["Publisher", event.publisher]) + results.append(["State", event.state]) + results.append(["Event", event.event]) + results.append(["Service", event.service]) + results.append(["Host", event.host]) + results.append(["UUID", event.instance]) + results.append(["Req ID", event.request_id]) + return results + +def _append_raw_attributes(event, results, service): + if service == 'nova': + return append_nova_raw_attributes(event, results) + if service == 'glance': + return append_glance_raw_attributes(event, results) + if service == 'generic': + return append_generic_raw_attributes(event, results) + +def do_show(request, event_id, service='nova'): + event_id = int(event_id) + results = [] + model = _model_factory(service) + try: + event = model.get(id=event_id) + results = _append_raw_attributes(event, results, service) + final = [results, ] + j = json.loads(event.json) + final.append(json.dumps(j, indent=2)) + final.append(event.uuid) + return rsp(json.dumps(final)) + except ObjectDoesNotExist: + return rsp({}) + + +def _model_factory(service): + if service == 'glance': + return models.GlanceRawData.objects + elif service == 'nova': + return models.RawData.objects + elif service == 'generic': + return models.GenericRawData.objects + + +def do_watch(request, deployment_id, service='nova'): + model = _model_factory(service) deployment_id = int(deployment_id) since = request.GET.get('since') event_name = request.GET.get('event_name') @@ -244,7 +301,7 @@ def do_watch(request, deployment_id): events = get_event_names() max_event_width = max([len(event['event']) for event in events]) - base_events = models.RawData.objects.order_by('when') + base_events = model.order_by('when') if deployment_id > 0: base_events = base_events.filter(deployment=deployment_id) @@ -426,3 +483,26 @@ def do_jsonreport(request, report_id): report_id = int(report_id) report = get_object_or_404(models.JsonReport, pk=report_id) return rsp(report.json) + + +def search(request, service): + DEFAULT = 1000 + field = request.GET.get('field') + value = request.GET.get('value') + limit = request.GET.get('limit', DEFAULT) + limit = int(limit) + model = _model_factory(service) + filter_para = {field: value} + results = {} + try: + events = model.filter(**filter_para) + event_len = len(events) + if event_len > limit: + events = events[0:limit] + for event in events: + when = dt.dt_from_decimal(event.when) + routing_key_status = routing_key_type(event.routing_key) + results = event.search_results(results, when, routing_key_status) + return rsp(json.dumps(results)) + except ObjectDoesNotExist or FieldError: + return rsp({}) diff --git a/stacktach/tests.py b/stacktach/tests.py index d3760b6..a2549a7 100644 --- a/stacktach/tests.py +++ b/stacktach/tests.py @@ -27,6 +27,8 @@ from stacktach.models import GenericRawData from stacktach.models import GlanceRawData from stacktach.models import RawData from stacktach.models import get_model_fields +from stacktach import datetime_to_decimal as dt + class RawDataImageMetaDbTestCase(TransactionTestCase): @@ -157,3 +159,84 @@ class GenericRawDataTestCase(TransactionTestCase): if field.name != 'id': self.assertEquals(getattr(rawdata, field.name), kwargs[field.name]) + + +class NovaRawDataSearchTestCase(TransactionTestCase): + def test_search_results_for_nova(self): + expected_result = [['#', '?', 'When', 'Deployment', 'Event', 'Host', + 'State', "State'", "Task'"], [1L, ' ', + '2013-07-17 10:16:10.717219', 'depl', 'event', + 'host', 'state', 'old_state', 'old_task']] + depl = db.get_or_create_deployment('depl')[0] + when = dt.dt_to_decimal(datetime.utcnow()) + raw = db.create_nova_rawdata(deployment=depl, + routing_key='routing_key', + tenant='tenant', + json='json', + when=when, + publisher='publisher', + event='event', + service='nova', + host='host', + instance='instance', + request_id='req-1234', + state='state', + old_state='old_state', + task='task', + old_task='old_task', + os_architecture='arch', + os_distro='distro', + os_version='version', + rax_options=1) + + results = raw.search_results({}, "2013-07-17 10:16:10.717219", ' ') + self.assertEqual(results,expected_result) + + def test_search_results_for_glance(self): + expected_result = [['#', '?', 'When', 'Deployment', 'Event', 'Host', + 'Status'], [1L, ' ', + '2013-07-17 10:16:10.717219', 'depl', 'event', + 'host', 'status']] + depl = db.get_or_create_deployment('depl')[0] + when = dt.dt_to_decimal(datetime.utcnow()) + + glance_raw = db.create_glance_rawdata(deployment=depl, + routing_key='routing_key', + json='json', + when=when, + publisher='publisher', + event='event', + service='glance', + host='host', + uuid='instance', + request_id='req-1234', + status='status', + image_type=1) + + results = glance_raw.search_results({}, "2013-07-17 10:16:10.717219", + ' ') + self.assertEqual(results,expected_result) + + def test_search_results_for_generic(self): + expected_result = [['#', '?', 'When', 'Deployment', 'Event', 'Host', + 'Instance', 'Request id'], [1L, ' ', + '2013-07-17 10:16:10.717219', 'depl', 'event', + 'host', 'instance', 'req-1234']] + depl = db.get_or_create_deployment('depl')[0] + when = dt.dt_to_decimal(datetime.utcnow()) + + generic_raw = db.create_generic_rawdata(deployment=depl, + routing_key='routing_key', + json='json', + when=when, + publisher='publisher', + event='event', + service='glance', + host='host', + instance='instance', + request_id='req-1234', + tenant='tenant') + + results = generic_raw.search_results({}, "2013-07-17 10:16:10.717219", + ' ') + self.assertEqual(results,expected_result) diff --git a/stacktach/urls.py b/stacktach/urls.py index 3670d30..e82788f 100644 --- a/stacktach/urls.py +++ b/stacktach/urls.py @@ -1,4 +1,4 @@ -from django.conf.urls.defaults import patterns, include, url +from django.conf.urls import patterns, url urlpatterns = patterns('', @@ -7,7 +7,7 @@ urlpatterns = patterns('', url(r'stacky/deployments/$', 'stacktach.stacky_server.do_deployments'), url(r'stacky/events/$', 'stacktach.stacky_server.do_events'), url(r'stacky/hosts/$', 'stacktach.stacky_server.do_hosts'), - url(r'stacky/uuid/$', 'stacktach.stacky_server.do_uuid'), + url(r'stacky/uuid/(?P\w+)/$', 'stacktach.stacky_server.do_uuid'), url(r'stacky/timings/$', 'stacktach.stacky_server.do_timings'), url(r'stacky/timings/uuid/$', 'stacktach.stacky_server.do_timings_uuid'), url(r'stacky/summary/$', 'stacktach.stacky_server.do_summary'), @@ -17,8 +17,11 @@ urlpatterns = patterns('', 'stacktach.stacky_server.do_jsonreport'), url(r'stacky/show/(?P\d+)/$', 'stacktach.stacky_server.do_show'), - url(r'stacky/watch/(?P\d+)/$', + url(r'stacky/show/(?P\w+)/(?P\d+)$', + 'stacktach.stacky_server.do_show'), + url(r'stacky/watch/(?P\d+)/(?P\w+)$', 'stacktach.stacky_server.do_watch'), + url(r'stacky/search/(?P\w+)/$', 'stacktach.stacky_server.search'), url(r'stacky/kpi/$', 'stacktach.stacky_server.do_kpi'), url(r'stacky/kpi/(?P\w+)/$', 'stacktach.stacky_server.do_kpi'), url(r'stacky/usage/launches/$', diff --git a/tests/unit/test_stacky_server.py b/tests/unit/test_stacky_server.py index 0b0ee24..96e011b 100644 --- a/tests/unit/test_stacky_server.py +++ b/tests/unit/test_stacky_server.py @@ -40,6 +40,12 @@ class StackyServerTestCase(unittest.TestCase): self.mox.StubOutWithMock(models, 'RawData', use_mock_anything=True) models.RawData.objects = self.mox.CreateMockAnything() self.mox.StubOutWithMock(models, 'Deployment', use_mock_anything=True) + self.mox.StubOutWithMock(models, 'GlanceRawData', + use_mock_anything=True) + models.GlanceRawData.objects = self.mox.CreateMockAnything() + self.mox.StubOutWithMock(models, 'GenericRawData', + use_mock_anything=True) + models.GenericRawData.objects = self.mox.CreateMockAnything() models.Deployment.objects = self.mox.CreateMockAnything() self.mox.StubOutWithMock(models, 'Lifecycle', use_mock_anything=True) models.Lifecycle.objects = self.mox.CreateMockAnything() @@ -65,7 +71,8 @@ class StackyServerTestCase(unittest.TestCase): def _create_raw(self): raw = self.mox.CreateMockAnything() - raw.when = utils.decimal_utc() + raw.when = utils.decimal_utc(datetime.datetime(2013, 7, 17, 10, 16, + 10, 717219)) raw.instance = INSTANCE_ID_1 raw.id = 1 raw.routing_key = 'monitor.info' @@ -80,13 +87,19 @@ class StackyServerTestCase(unittest.TestCase): raw.publisher = "api.example.com" raw.service = 'api' raw.host = 'example.com' + raw.status = 'state' raw.request_id = REQUEST_ID_1 raw.json = '{"key": "value"}' + raw.uuid = 'uuid' + raw.tenant = 'tenant' return raw def test_get_event_names(self): + model = self.mox.CreateMockAnything() result = self.mox.CreateMockAnything() - models.RawData.objects.values('event').AndReturn(result) + self.mox.StubOutWithMock(stacky_server, '_model_factory') + stacky_server._model_factory('nova').AndReturn(model) + model.values('event').AndReturn(result) result.distinct().AndReturn(result) self.mox.ReplayAll() @@ -248,6 +261,10 @@ class StackyServerTestCase(unittest.TestCase): self.mox.VerifyAll() def test_do_uuid(self): + search_result = [["#", "?", "When", "Deployment", "Event", "Host", + "State", "State'", "Task'"], [1, " ", + "2013-07-17 10:16:10.717219", "deployment", + "test.start", "example.com", "active", None, None]] fake_request = self.mox.CreateMockAnything() fake_request.GET = {'uuid': INSTANCE_ID_1} result = self.mox.CreateMockAnything() @@ -256,6 +273,7 @@ class StackyServerTestCase(unittest.TestCase): result.order_by('when').AndReturn(result) raw = self._create_raw() result.__iter__().AndReturn([raw].__iter__()) + raw.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result) self.mox.ReplayAll() resp = stacky_server.do_uuid(fake_request) @@ -272,6 +290,36 @@ class StackyServerTestCase(unittest.TestCase): self.assertEqual(json_resp[1], body) self.mox.VerifyAll() + def test_do_uuid_for_glance(self): + search_result = [["#", "?", "When", "Deployment", "Event", "Host", + "Status"], [1, " ", + "2013-07-17 10:16:10.717219", "deployment", + "test.start", "example.com", "state"]] + fake_request = self.mox.CreateMockAnything() + fake_request.GET = {'uuid': INSTANCE_ID_1} + result = self.mox.CreateMockAnything() + models.GlanceRawData.objects.select_related().AndReturn(result) + result.filter(uuid=INSTANCE_ID_1).AndReturn(result) + result.order_by('when').AndReturn(result) + raw = self._create_raw() + result.__iter__().AndReturn([raw].__iter__()) + raw.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result) + self.mox.ReplayAll() + + resp = stacky_server.do_uuid(fake_request,'glance') + + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self.assertEqual(len(json_resp), 2) + header = ["#", "?", "When", "Deployment", "Event", "Host", + "Status"] + self.assertEqual(json_resp[0], header) + datetime = dt.dt_from_decimal(raw.when) + body = [1, " ", str(datetime), "deployment", "test.start", + "example.com", "state"] + self.assertEqual(json_resp[1], body) + self.mox.VerifyAll() + def test_do_uuid_bad_uuid(self): fake_request = self.mox.CreateMockAnything() fake_request.GET = {'uuid': "obviouslybaduuid"} @@ -504,7 +552,9 @@ class StackyServerTestCase(unittest.TestCase): self.assertEqual(resp_json[1], ['Bad Request', msg]) self.mox.VerifyAll() - def _assert_on_show(self, values, raw): + def _assert_on_show_nova(self, json_resp, raw): + self.assertEqual(len(json_resp), 3) + values = json_resp[0] self.assertEqual(len(values), 12) self.assertEqual(values[0], ["Key", "Value"]) self.assertEqual(values[1], ["#", raw.id]) @@ -517,7 +567,25 @@ class StackyServerTestCase(unittest.TestCase): self.assertEqual(values[7], ["Event", raw.event]) self.assertEqual(values[8], ["Service", raw.service]) self.assertEqual(values[9], ["Host", raw.host]) - self.assertEqual(values[10], ["UUID", raw.instance]) + self.assertEqual(values[10],["UUID", raw.instance]) + self.assertEqual(values[11], ["Req ID", raw.request_id]) + + def _assert_on_show_glance(self, json_resp, raw): + self.assertEqual(len(json_resp), 3) + values = json_resp[0] + self.assertEqual(len(values), 12) + self.assertEqual(values[0], ["Key", "Value"]) + self.assertEqual(values[1], ["#", raw.id]) + self.assertEqual(values[2], ["When", + str(dt.dt_from_decimal(raw.when))]) + self.assertEqual(values[3], ["Deployment", raw.deployment.name]) + self.assertEqual(values[4], ["Category", raw.routing_key]) + self.assertEqual(values[5], ["Publisher", raw.publisher]) + self.assertEqual(values[6], ["Status", raw.status]) + self.assertEqual(values[7], ["Event", raw.event]) + self.assertEqual(values[8], ["Service", raw.service]) + self.assertEqual(values[9], ["Host", raw.host]) + self.assertEqual(values[10],["UUID", raw.uuid]) self.assertEqual(values[11], ["Req ID", raw.request_id]) def test_do_show(self): @@ -528,10 +596,81 @@ class StackyServerTestCase(unittest.TestCase): resp = stacky_server.do_show(fake_request, 1) + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self._assert_on_show_nova(json_resp, raw) + self.mox.VerifyAll() + + def test_do_show_for_glance_rawdata(self): + fake_request = self.mox.CreateMockAnything() + raw = self._create_raw() + models.GlanceRawData.objects.get(id=1).AndReturn(raw) + self.mox.ReplayAll() + + resp = stacky_server.do_show(fake_request, 1, 'glance') + + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self._assert_on_show_glance(json_resp, raw) + self.mox.VerifyAll() + + def test_do_show_for_generic_rawdata(self): + fake_request = self.mox.CreateMockAnything() + raw = self._create_raw() + models.GenericRawData.objects.get(id=1).AndReturn(raw) + self.mox.ReplayAll() + + resp = stacky_server.do_show(fake_request, 1, 'generic') + + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self._assert_on_show_nova(json_resp, raw) + self.mox.VerifyAll() + + def test_do_show_should_return_empty_result_on_object_not_found_exception(self): + fake_request = self.mox.CreateMockAnything() + raw = self._create_raw() + models.RawData.objects.get(id=1).AndReturn(raw) + self.mox.ReplayAll() + + resp = stacky_server.do_show(fake_request, 1) + + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self._assert_on_show_nova(json_resp, raw) + self.mox.VerifyAll() + + def test_do_watch_for_glance(self): + fake_request = self.mox.CreateMockAnything() + fake_request.GET = {} + self.mox.StubOutWithMock(stacky_server, 'get_deployments') + deployment1 = self.mox.CreateMockAnything() + deployment1.id = 1 + deployment1.name = 'dep1' + deployments = [deployment1] + stacky_server.get_deployments().AndReturn(deployments) + self.mox.StubOutWithMock(stacky_server, 'get_event_names') + events = [{'event': 'test.start'}, {'event': 'test.end'}] + stacky_server.get_event_names().AndReturn(events) + results = self.mox.CreateMockAnything() + models.GlanceRawData.objects.order_by('when').AndReturn(results) + results.filter(when__gt=mox.IgnoreArg()).AndReturn(results) + results.filter(when__lte=mox.IgnoreArg()).AndReturn(results) + results.__iter__().AndReturn([self._create_raw()].__iter__()) + self.mox.ReplayAll() + + resp = stacky_server.do_watch(fake_request, 0, 'glance') self.assertEqual(resp.status_code, 200) json_resp = json.loads(resp.content) self.assertEqual(len(json_resp), 3) - self._assert_on_show(json_resp[0], raw) + self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36]) + self.assertEqual(json_resp[1][0][0], 1) + self.assertEqual(json_resp[1][0][1], u' ') + time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3]) + datetime.datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S.%f") + self.assertEqual(json_resp[1][0][4], u'dep1') + self.assertEqual(json_resp[1][0][5], u'test.start') + self.assertEqual(json_resp[1][0][6], u'%s' % INSTANCE_ID_1) self.mox.VerifyAll() def test_do_watch(self): @@ -547,7 +686,10 @@ class StackyServerTestCase(unittest.TestCase): events = [{'event': 'test.start'}, {'event': 'test.end'}] stacky_server.get_event_names().AndReturn(events) results = self.mox.CreateMockAnything() - models.RawData.objects.order_by('when').AndReturn(results) + model = self.mox.CreateMockAnything() + self.mox.StubOutWithMock(stacky_server, '_model_factory') + stacky_server._model_factory('nova').AndReturn(model) + model.order_by('when').AndReturn(results) results.filter(when__gt=mox.IgnoreArg()).AndReturn(results) results.filter(when__lte=mox.IgnoreArg()).AndReturn(results) results.__iter__().AndReturn([self._create_raw()].__iter__()) @@ -558,7 +700,6 @@ class StackyServerTestCase(unittest.TestCase): json_resp = json.loads(resp.content) self.assertEqual(len(json_resp), 3) self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36]) - print json_resp self.assertEqual(json_resp[1][0][0], 1) self.assertEqual(json_resp[1][0][1], u' ') time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3]) @@ -581,7 +722,11 @@ class StackyServerTestCase(unittest.TestCase): events = [{'event': 'test.start'}, {'event': 'test.end'}] stacky_server.get_event_names().AndReturn(events) results = self.mox.CreateMockAnything() - models.RawData.objects.order_by('when').AndReturn(results) + model = self.mox.CreateMockAnything() + self.mox.StubOutWithMock(stacky_server, '_model_factory') + stacky_server._model_factory('nova').AndReturn(model) + model.order_by('when').AndReturn(results) + results.filter(deployment=1).AndReturn(results) results.filter(when__gt=mox.IgnoreArg()).AndReturn(results) results.filter(when__lte=mox.IgnoreArg()).AndReturn(results) @@ -593,7 +738,6 @@ class StackyServerTestCase(unittest.TestCase): json_resp = json.loads(resp.content) self.assertEqual(len(json_resp), 3) self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36]) - print json_resp self.assertEqual(json_resp[1][0][0], 1) self.assertEqual(json_resp[1][0][1], u' ') time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3]) @@ -628,7 +772,6 @@ class StackyServerTestCase(unittest.TestCase): json_resp = json.loads(resp.content) self.assertEqual(len(json_resp), 3) self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36]) - print json_resp self.assertEqual(json_resp[1][0][0], 1) self.assertEqual(json_resp[1][0][1], u' ') time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3]) @@ -960,3 +1103,82 @@ class StackyServerTestCase(unittest.TestCase): self.assertEqual(resp_json[1], ['Bad Request', msg]) self.mox.VerifyAll() + def test_model_factory_for_nova(self): + self.mox.UnsetStubs() + nova_model = stacky_server._model_factory('nova') + self.assertEqual(nova_model.model, models.RawData) + + def test_model_factory_for_nova(self): + self.mox.UnsetStubs() + nova_model = stacky_server._model_factory('glance') + self.assertEqual(nova_model.model, models.GlanceRawData) + + def test_model_factory_for_nova(self): + self.mox.UnsetStubs() + nova_model = stacky_server._model_factory('generic') + self.assertEqual(nova_model.model, models.GenericRawData) + + def _assert_on_search_nova(self, json_resp, raw): + title = json_resp[0] + values = json_resp[1] + self.assertEqual(len(values), 9) + self.assertEqual([title[0], values[0]],["#", raw.id] ) + self.assertEqual([title[1], values[1]], ['?', ' ']) + self.assertEqual([title[2], values[2]], ["When", + str(dt.dt_from_decimal(raw.when))]) + self.assertEqual([title[3], values[3]], ["Deployment", raw.deployment.name]) + self.assertEqual([title[4], values[4]], ["Event", raw.event]) + self.assertEqual([title[5], values[5]], ["Host", raw.host]) + self.assertEqual([title[6], values[6]], ["State", raw.state]) + self.assertEqual([title[7], values[7]], ["State'", raw.old_state]) + + def test_search_by_field_for_nova(self): + search_result = [["#", "?", "When", "Deployment", "Event", "Host", + "State", "State'", "Task'"], [1, " ", + "2013-07-17 10:16:10.717219", "deployment", + "test.start", "example.com", "active", None, None]] + fake_request = self.mox.CreateMockAnything() + fake_request.GET = {'field': 'tenant', 'value': 'tenant'} + raw = self._create_raw() + models.RawData.objects.filter(tenant='tenant').AndReturn([raw]) + raw.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result) + self.mox.ReplayAll() + + resp = stacky_server.search(fake_request, 'nova') + + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self._assert_on_search_nova(json_resp, raw) + self.mox.VerifyAll() + + def test_search_by_field_for_nova_with_limit(self): + search_result = [["#", "?", "When", "Deployment", "Event", "Host", + "State", "State'", "Task'"], [1, " ", + "2013-07-17 10:16:10.717219", "deployment", + "test.start", "example.com", "active", None, None]] + search_result_2 = [["#", "?", "When", "Deployment", "Event", "Host", + "State", "State'", "Task'"], [1, " ", + "2013-07-17 10:16:10.717219", "deployment", + "test.start", "example.com", "active", None, None],[2, " ", + "2013-07-17 10:16:10.717219", "deployment", + "test.start", "example.com", "active", None, None]] + fake_request = self.mox.CreateMockAnything() + fake_request.GET = {'field': 'tenant', 'value': 'tenant', 'limit': '2'} + raw1 = self._create_raw() + raw2 = self._create_raw() + raw3 = self._create_raw() + raw2.id = 2 + raw3.id = 3 + models.RawData.objects.filter(tenant='tenant').AndReturn([raw1, raw2, + raw3]) + raw1.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result) + raw2.search_results(search_result, mox.IgnoreArg(),' ').AndReturn(search_result_2) + self.mox.ReplayAll() + + resp = stacky_server.search(fake_request, 'nova') + + self.assertEqual(resp.status_code, 200) + json_resp = json.loads(resp.content) + self.assertEqual(len(json_resp), 3) + self._assert_on_search_nova(json_resp, raw1) + self.mox.VerifyAll() \ No newline at end of file