diff --git a/swh/web/ui/static/js/calendar.js b/swh/web/ui/static/js/calendar.js
new file mode 100644
index 00000000..901dbab0
--- /dev/null
+++ b/swh/web/ui/static/js/calendar.js
@@ -0,0 +1,391 @@
+/**
+ * Calendar:
+ * A one-off object that makes an AJAX call to the API's visit stats
+ * endpoint, then displays these statistics in a zoomable timeline-like
+ * format.
+ * Args:
+ * browse_url: the relative URL for browsing a revision via the web ui,
+ * accurate up to the origin
+ * visit_url: the complete relative URL for getting the origin's visit
+ * stats
+ * origin_id: the origin being browsed
+ * zoomw: the
+ * of the calendar
+ * staticw: the element that should contain the static part of the calendar
+ * reset: the element that should reset the zoom level on click
+ */
+
+var Calendar = function(browse_url, visit_url, origin_id,
+ zoomw, staticw, reset) {
+
+ /** Constants **/
+ this.month_names = ['Jan', 'Feb', 'Mar',
+ 'Apr', 'May', 'Jun',
+ 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+ /** Display **/
+ this.desiredPxWidth = 7;
+ this.padding = 0.01;
+
+ /** Object vars **/
+ this.origin_id = origin_id;
+ this.zoomw = zoomw;
+ this.staticw = staticw;
+ /** Calendar data **/
+ this.cal_data = null;
+ this.static = {
+ group_factor: 3600 * 1000,
+ group_data: null,
+ plot_data: null
+ };
+ this.zoom = {
+ group_factor: 3600 * 1000,
+ group_data: null,
+ plot_data: null
+ };
+
+ var self = this;
+
+ /** Start AJAX call **/
+ $.ajax({
+ type: 'GET',
+ url: visit_url,
+ success: function(data) {
+ self.calendar(data);
+ }
+ });
+
+ /**
+ * Group the plot's base data according to the grouping ratio
+ * Args:
+ * groupFactor: the amount the data should be grouped by
+ * Returns:
+ * A dictionary containing timestamps divided by the grouping ratio as
+ * keys, a list of the corresponding complete timestamps as values
+ */
+ this.dataGrouped = function(groupFactor) {
+ var group_dict = {};
+ for (const date of self.cal_data) {
+ var floor = Math.floor(date / groupFactor);
+ if (group_dict[floor] == undefined)
+ group_dict[floor] = [date];
+ else
+ group_dict[floor].push(date);
+ }
+ return group_dict;
+ };
+
+ /**
+ */
+ this.dataGroupedRange = function(groupFactor, range) {
+ var group_dict = {};
+ var start = range.xaxis.from;
+ var end = range.xaxis.to;
+ var range_data = self.cal_data.filter(function(item, index, arr) {
+ return item >= start && item <= end;
+ });
+ for (const date of range_data) {
+ var floor = Math.floor(date / groupFactor);
+ if (group_dict[floor] == undefined)
+ group_dict[floor] = [date];
+ else
+ group_dict[floor].push(date);
+ }
+ return group_dict;
+ };
+
+ /**
+ * Update the ratio that governs how the data is grouped based on changes
+ * in the data range or the display size, and regroup the plot's data
+ * according to this value.
+ *
+ * Args:
+ * element: the element in which the plot is displayed
+ * plotprops: the properties corresponding to that plot
+ * range: the range of the data displayed
+ */
+ this.updateGroupFactorAndData = function(element, plotprops, range) {
+ var milli_length = range.xaxis.to - range.xaxis.from;
+ var px_length = element.width();
+ plotprops.group_factor = Math.floor(
+ self.desiredPxWidth * (milli_length / px_length));
+ plotprops.group_data = self.dataGroupedRange(
+ plotprops.group_factor, range);
+ };
+
+
+ /** Get plot data from the group data **/
+ this.getPlotData = function(grouped_data) {
+ var plot_data = [];
+ if (self.cal_data.length == 1) {
+ plot_data = [[self.cal_data[0] - 3600*1000*24*30, 0],
+ [self.cal_data[0], 1],
+ [self.cal_data[0] + 3600*1000*24*30, 0]];
+ }
+ else {
+ $.each(grouped_data, function(key, value) {
+ plot_data.push([value[0], value.length]);
+ });
+ }
+ return [{ label: 'Calendar', data: plot_data }];
+ };
+
+ this.plotZoom = function(zoom_options) {
+ return $.plot(self.zoomw, self.zoom.plot_data, zoom_options);
+ };
+
+ this.plotStatic = function(static_options) {
+ return $.plot(self.staticw, self.static.plot_data, static_options);
+ };
+
+ /**
+ * Display a zoomable calendar with click-through links to revisions
+ * of the same origin
+ *
+ * Args:
+ * data: the data that the calendar should present, as a list of
+ * POSIX second-since-epoch timestamps
+ */
+ this.calendar = function(data) {
+ // POSIX timestamps to JS timestamps
+ self.cal_data = data.map(function(e)
+ { return Math.floor(e * 1000); });
+ /** Bootstrap the group ratio **/
+ var cal_data_range = null;
+ if (self.cal_data.length == 1)
+ cal_data_range = {xaxis: {from: self.cal_data[0] - 3600*1000*24*30,
+ to: self.cal_data[0] + 3600*1000*24*30}};
+ else
+ cal_data_range = {xaxis: {from: self.cal_data[0],
+ to: self.cal_data[self.cal_data.length -1]
+ }
+ };
+ self.updateGroupFactorAndData(self.zoomw,
+ self.zoom,
+ cal_data_range);
+ self.updateGroupFactorAndData(self.staticw,
+ self.static,
+ cal_data_range);
+ /** Bootstrap the plot data **/
+ self.zoom.plot_data = self.getPlotData(self.zoom.group_data);
+ self.static.plot_data = self.getPlotData(self.zoom.group_data);
+
+ function date_to_tooltip_zoom(label, x_timestamp, y_hits, item) {
+ var floor_index = Math.floor(
+ item.datapoint[0] / self.zoom.group_factor);
+ var tooltip_text = self.zoom.group_data[floor_index].map(
+ function(elem) {
+ var date = new Date(elem);
+ var year = (date.getYear() + 1900).toString();
+ var month = self.month_names[date.getMonth()];
+ var day = date.getDate();
+ var hr = date.getHours();
+ var min = date.getMinutes();
+ if (min < 10) min = '0'+min;
+ return [day,
+ month,
+ year + ',',
+ hr+':'+min,
+ 'UTC'].join(' ');
+ }
+ );
+ return tooltip_text.join('
');
+ }
+
+ function date_to_tooltip_static(label, x_timestamp, y_hits, item) {
+ var floor_index = Math.floor(
+ item.datapoint[0] / self.static.group_factor);
+ var tooltip_text = self.static.group_data[floor_index].map(
+ function(elem) {
+ var date = new Date(elem);
+ var year = (date.getYear() + 1900).toString();
+ var month = self.month_names[date.getMonth()];
+ var day = date.getDate();
+ var hr = date.getHours();
+ var min = date.getMinutes();
+ if (min < 10) min = '0'+min;
+ return [day,
+ month,
+ year + ',',
+ hr+':'+min,
+ 'UTC'].join(' ');
+ }
+ );
+ return tooltip_text.join('
');
+ }
+
+ /** Plot options for both graph windows **/
+ var zoom_options = {
+ legend: {
+ show: false
+ },
+ series: {
+ clickable: true,
+ bars: {
+ show: true,
+ lineWidth: 1,
+ barWidth: self.zoom.group_factor
+ }
+ },
+ xaxis: {
+ mode: 'time',
+ minTickSize: [1, 'day'],
+ // monthNames: self.month_names,
+ position: 'top'
+ },
+ yaxis: {
+ show: false
+ },
+ selection: {
+ mode: 'x'
+ },
+ grid: {
+ clickable: true,
+ hoverable: true
+ },
+ tooltip: {
+ show: true,
+ content: date_to_tooltip_zoom
+ }
+ };
+
+ var overview_options = {
+ legend: {
+ show: false
+ },
+ series: {
+ clickable: true,
+ bars: {
+ show: true,
+ lineWidth: 1,
+ barWidth: self.static.group_factor
+ },
+ shadowSize: 0
+ },
+ yaxis: {
+ show: false
+ },
+ xaxis: {
+ mode: 'time',
+ minTickSize: [1, 'day']
+ },
+ grid: {
+ clickable: true,
+ hoverable: true,
+ color: '#999'
+ },
+ selection: {
+ mode: 'x'
+ },
+ tooltip: {
+ show: true,
+ content: date_to_tooltip_static
+ }
+ };
+
+ function addPadding(options, range) {
+ var len = range.xaxis.to - range.xaxis.from;
+ return $.extend(true, {}, options, {
+ xaxis: {
+ min: range.xaxis.from - (self.padding * len),
+ max: range.xaxis.to + (self.padding * len)
+ }
+ });
+ }
+
+ /** draw the windows **/
+ var plot = self.plotZoom(addPadding(zoom_options, cal_data_range));
+ var overview = self.plotStatic(
+ addPadding(overview_options, cal_data_range));
+
+ var current_ranges = $.extend(true, {}, cal_data_range);
+
+ /**
+ * Zoom to the mouse-selected range in the given window
+ *
+ * Args:
+ * plotzone: the jQuery-selected element the zoomed plot should be
+ * in (usually the same as the original 'zoom plot' element)
+ * range: the data range as a dict {xaxis: {from:, to:},
+ * yaxis:{from:, to:}}
+ */
+ function zoom(ranges) {
+ current_ranges.xaxis.from = ranges.xaxis.from;
+ current_ranges.xaxis.to = ranges.xaxis.to;
+ self.updateGroupFactorAndData(
+ self.zoomw, self.zoom, current_ranges);
+ self.zoom.plot_data = self.getPlotData(self.zoom.group_data);
+ var zoomedopts = $.extend(true, {}, zoom_options, {
+ xaxis: { min: ranges.xaxis.from, max: ranges.xaxis.to },
+ series: {
+ bars: {barWidth: self.zoom.group_factor}
+ }
+ });
+ return self.plotZoom(zoomedopts);
+ }
+
+ function resetZoomW(plot_options) {
+ self.zoom.group_data = self.static.group_data;
+ self.zoom.plot_data = self.static.plot_data;
+ self.updateGroupFactorAndData(zoomw, self.zoom, cal_data_range);
+ plot = self.plotZoom(addPadding(plot_options, cal_data_range));
+ }
+
+ // now connect the two
+ self.zoomw.bind('plotselected', function (event, ranges) {
+ // clamp the zooming to prevent eternal zoom
+ if (ranges.xaxis.to - ranges.xaxis.from < 0.00001)
+ ranges.xaxis.to = ranges.xaxis.from + 0.00001;
+ // do the zooming
+ plot = zoom(ranges);
+ // don't fire event on the overview to prevent eternal loop
+ overview.setSelection(ranges, true);
+ });
+
+ self.staticw.bind('plotselected', function (event, ranges) {
+ plot.setSelection(ranges);
+ });
+
+ function unbindClick() {
+ self.zoomw.unbind('plotclick');
+ self.staticw.unbind('plotclick');
+ }
+
+ function bindClick() {
+ self.zoomw.bind('plotclick', redirect_to_revision);
+ self.staticw.bind('plotclick', redirect_to_revision);
+ }
+
+ function redirect_to_revision(event, pos, item) {
+ if (item) {
+ var ts = Math.floor(item.datapoint[0] / 1000); // POSIX ts
+ var url = browse_url + 'ts/' + ts + '/';
+ window.location.href = url;
+ }
+ }
+
+ reset.click(function(event) {
+ plot.clearSelection();
+ overview.clearSelection();
+ current_ranges = $.extend(true, {}, cal_data_range);
+ resetZoomW(zoom_options);
+ });
+
+ $(window).resize(function(event) {
+ /** Update zoom display **/
+ self.updateGroupFactorAndData(zoomw, self.zoom, current_ranges);
+ self.zoom.plot_data = self.getPlotData(self.zoom.group_data);
+ /** Update static display **/
+ self.updateGroupFactorAndData(staticw, self.static, cal_data_range);
+ self.static.plot_data = self.getPlotData(self.static.group_data);
+ /** Replot **/
+ plot = self.plotZoom(
+ addPadding(zoom_options, current_ranges));
+ overview = self.plotStatic(
+ addPadding(overview_options, cal_data_range));
+ });
+
+ bindClick();
+ };
+};
diff --git a/swh/web/ui/templates/origin.html b/swh/web/ui/templates/origin.html
index d2ccd5d8..ec3465a4 100644
--- a/swh/web/ui/templates/origin.html
+++ b/swh/web/ui/templates/origin.html
@@ -1,27 +1,41 @@
{% extends "layout.html" %}
{% block title %}Origin{% endblock %}
{% block content %}
{% if message is not none %}
{{ message }}
{% endif %}
{% if origin is not none %}
+
+
+
+
+
+
Details on origin {{ origin_id }}:
+
+
{% for key in ['type', 'lister', 'projet', 'url'] %}
{% if origin[key] is not none %}
{{ key }}
{{ origin[key] }}
{% endif %}
{% endfor %}
{% if 'decoding_failures' in content %}
- {% endif %}
+ {% endif %}
+
{% endif %}
{% endblock %}
diff --git a/swh/web/ui/tests/views/test_browse.py b/swh/web/ui/tests/views/test_browse.py
index 2b353f5f..c1920fe7 100644
--- a/swh/web/ui/tests/views/test_browse.py
+++ b/swh/web/ui/tests/views/test_browse.py
@@ -1,1692 +1,1704 @@
# Copyright (C) 2015 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from unittest.mock import patch
from swh.web.ui.exc import BadInputExc, NotFoundExc
from .. import test_app
class FileMock():
def __init__(self, filename):
self.filename = filename
class SearchView(test_app.SWHViewTestCase):
render_template = False
@istest
def search_default(self):
# when
rv = self.client.get('/search/')
self.assertEqual(rv.status_code, 200)
self.assertEqual(self.get_context_variable('message'), '')
self.assertEqual(self.get_context_variable('search_res'), None)
self.assert_template_used('upload_and_search.html')
@patch('swh.web.ui.views.browse.api')
@istest
def search_get_query_hash_not_found(self, mock_api):
# given
mock_api.api_search.return_value = {
'search_res': [{
'filename': None,
'sha1': 'sha1:456',
'found': False}],
'search_stats': {'nbfiles': 1, 'pct': 100}}
# when
rv = self.client.get('/search/?q=sha1:456')
self.assertEqual(rv.status_code, 200)
self.assertEqual(self.get_context_variable('message'), '')
self.assertEqual(self.get_context_variable('search_res'), [
{'filename': None,
'sha1': 'sha1:456',
'found': False}])
self.assert_template_used('upload_and_search.html')
mock_api.api_search.assert_called_once_with('sha1:456')
@patch('swh.web.ui.views.browse.api')
@istest
def search_get_query_hash_bad_input(self, mock_api):
# given
mock_api.api_search.side_effect = BadInputExc('error msg')
# when
rv = self.client.get('/search/?q=sha1_git:789')
self.assertEqual(rv.status_code, 200)
self.assertEqual(self.get_context_variable('message'), 'error msg')
self.assertEqual(self.get_context_variable('search_res'), None)
self.assert_template_used('upload_and_search.html')
mock_api.api_search.assert_called_once_with('sha1_git:789')
@patch('swh.web.ui.views.browse.api')
@istest
def search_get_query_hash_found(self, mock_api):
# given
mock_api.api_search.return_value = {
'search_res': [{
'filename': None,
'sha1': 'sha1:123',
'found': True}],
'search_stats': {'nbfiles': 1, 'pct': 100}}
# when
rv = self.client.get('/search/?q=sha1:123')
self.assertEqual(rv.status_code, 200)
self.assertEqual(self.get_context_variable('message'), '')
self.assertEqual(len(self.get_context_variable('search_res')), 1)
resp = self.get_context_variable('search_res')[0]
self.assertTrue(resp is not None)
self.assertEqual(resp['sha1'], 'sha1:123')
self.assertEqual(resp['found'], True)
self.assert_template_used('upload_and_search.html')
mock_api.api_search.assert_called_once_with('sha1:123')
@patch('swh.web.ui.views.browse.request')
@patch('swh.web.ui.views.browse.api')
@istest
def search_post_hashes_bad_input(self, mock_api, mock_request):
# given
mock_request.form = {'a': ['456caf10e9535160d90e874b45aa426de762f19f'],
'b': ['745bab676c8f3cec8016e0c39ea61cf57e518865']}
mock_request.method = 'POST'
mock_api.api_search.side_effect = BadInputExc(
'error bad input')
# when (mock_request completes the post request)
rv = self.client.post('/search/')
# then
self.assertEqual(rv.status_code, 200)
self.assertEqual(self.get_context_variable('search_stats'),
{'nbfiles': 0, 'pct': 0})
self.assertEqual(self.get_context_variable('search_res'), None)
self.assertEqual(self.get_context_variable('message'),
'error bad input')
self.assert_template_used('upload_and_search.html')
@patch('swh.web.ui.views.browse.request')
@patch('swh.web.ui.views.browse.api')
@istest
def search_post_hashes_none(self, mock_api, mock_request):
# given
mock_request.form = {'a': ['456caf10e9535160d90e874b45aa426de762f19f'],
'b': ['745bab676c8f3cec8016e0c39ea61cf57e518865']}
mock_request.method = 'POST'
mock_api.api_search.return_value = {
'search_stats': {'nbfiles': 2, 'pct': 0},
'search_res': [{'filename': 'a',
'sha1': '456caf10e9535160d90e874b45aa426de762f19f',
'found': False},
{'filename': 'b',
'sha1': '745bab676c8f3cec8016e0c39ea61cf57e518865',
'found': False}]}
# when (mock_request completes the post request)
rv = self.client.post('/search/')
# then
self.assertEqual(rv.status_code, 200)
self.assertIsNotNone(self.get_context_variable('search_res'))
self.assertTrue(self.get_context_variable('search_stats') is not None)
self.assertEqual(len(self.get_context_variable('search_res')), 2)
stats = self.get_context_variable('search_stats')
self.assertEqual(stats['nbfiles'], 2)
self.assertEqual(stats['pct'], 0)
a, b = self.get_context_variable('search_res')
self.assertEqual(a['found'], False)
self.assertEqual(b['found'], False)
self.assertEqual(self.get_context_variable('message'), '')
self.assert_template_used('upload_and_search.html')
@patch('swh.web.ui.views.browse.request')
@patch('swh.web.ui.views.browse.api')
@istest
def search_post_hashes_some(self, mock_api, mock_request):
# given
mock_request.form = {'a': '456caf10e9535160d90e874b45aa426de762f19f',
'b': '745bab676c8f3cec8016e0c39ea61cf57e518865'}
mock_request.method = 'POST'
mock_api.api_search.return_value = {
'search_stats': {'nbfiles': 2, 'pct': 50},
'search_res': [{'filename': 'a',
'sha1': '456caf10e9535160d90e874b45aa426de762f19f',
'found': False},
{'filename': 'b',
'sha1': '745bab676c8f3cec8016e0c39ea61cf57e518865',
'found': True}]}
# when (mock_request completes the post request)
rv = self.client.post('/search/')
# then
self.assertEqual(rv.status_code, 200)
self.assertIsNotNone(self.get_context_variable('search_res'))
self.assertEqual(len(self.get_context_variable('search_res')), 2)
self.assertTrue(self.get_context_variable('search_stats') is not None)
stats = self.get_context_variable('search_stats')
self.assertEqual(stats['nbfiles'], 2)
self.assertEqual(stats['pct'], 50)
self.assertEqual(self.get_context_variable('message'), '')
a, b = self.get_context_variable('search_res')
self.assertEqual(a['found'], False)
self.assertEqual(b['found'], True)
self.assert_template_used('upload_and_search.html')
class ContentView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_content_ko_not_found(self, mock_api):
# given
mock_api.api_content_metadata.side_effect = NotFoundExc(
'Not found!')
# when
rv = self.client.get('/browse/content/sha1:sha1-hash/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content.html')
self.assertEqual(self.get_context_variable('message'),
'Not found!')
self.assertIsNone(self.get_context_variable('content'))
mock_api.api_content_metadata.assert_called_once_with(
'sha1:sha1-hash')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_content_ko_bad_input(self, mock_api):
# given
mock_api.api_content_metadata.side_effect = BadInputExc(
'Bad input!')
# when
rv = self.client.get('/browse/content/sha1:sha1-hash/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content.html')
self.assertEqual(self.get_context_variable('message'),
'Bad input!')
self.assertIsNone(self.get_context_variable('content'))
mock_api.api_content_metadata.assert_called_once_with(
'sha1:sha1-hash')
@patch('swh.web.ui.views.browse.service')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_content(self, mock_api, mock_service):
# given
stub_content = {'sha1': 'sha1_hash'}
mock_api.api_content_metadata.return_value = stub_content
mock_service.lookup_content_raw.return_value = {'data': b'blah'}
expected_content = {'sha1': 'sha1_hash',
'data': 'blah'}
# when
rv = self.client.get('/browse/content/sha1:sha1-hash/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content.html')
self.assertIsNone(self.get_context_variable('message'))
self.assertEqual(self.get_context_variable('content'),
expected_content)
mock_service.lookup_content_raw.assert_called_once_with(
'sha1:sha1-hash')
mock_api.api_content_metadata.assert_called_once_with(
'sha1:sha1-hash')
@patch('swh.web.ui.views.browse.redirect')
@patch('swh.web.ui.views.browse.url_for')
@istest
def browse_content_raw(self, mock_urlfor, mock_redirect):
# given
stub_content_raw = b'some-data'
mock_urlfor.return_value = '/api/content/sha1:sha1-hash/raw/'
mock_redirect.return_value = stub_content_raw
# when
rv = self.client.get('/browse/content/sha1:sha1-hash/raw/')
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.data, stub_content_raw)
mock_urlfor.assert_called_once_with('api_content_raw',
q='sha1:sha1-hash')
mock_redirect.assert_called_once_with(
'/api/content/sha1:sha1-hash/raw/')
class DirectoryView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_ko_bad_input(self, mock_api):
# given
mock_api.api_directory.side_effect = BadInputExc(
'Invalid hash')
# when
rv = self.client.get('/browse/directory/sha2-invalid/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('directory.html')
self.assertEqual(self.get_context_variable('message'),
'Invalid hash')
self.assertEqual(self.get_context_variable('files'), [])
mock_api.api_directory.assert_called_once_with(
'sha2-invalid')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_empty_result(self, mock_api):
# given
mock_api.api_directory.return_value = []
# when
rv = self.client.get('/browse/directory/some-sha1/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('directory.html')
self.assertEqual(self.get_context_variable('message'),
'Listing for directory some-sha1:')
self.assertEqual(self.get_context_variable('files'), [])
mock_api.api_directory.assert_called_once_with(
'some-sha1')
@patch('swh.web.ui.views.browse.service')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_relative_file(self, mock_api, mock_service):
# given
stub_entry = {
'sha256': '240',
'type': 'file'
}
mock_service.lookup_directory_with_path.return_value = stub_entry
stub_file = {
'sha1_git': '123',
'sha1': '456',
'status': 'visible',
'data_url': '/api/1/content/890',
'length': 42,
'ctime': 'Thu, 01 Oct 2015 12:13:53 GMT',
'target': 'file.txt',
'sha256': '148'
}
mock_api.api_content_metadata.return_value = stub_file
mock_service.lookup_content_raw.return_value = {
'data': 'this is my file'}
# when
rv = self.client.get('/browse/directory/sha1/path/to/file/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content.html')
self.assertIsNotNone(self.get_context_variable('content'))
content = self.get_context_variable('content')
# change caused by call to prepare_data_for_view
self.assertEqual(content['data_url'], '/browse/content/890')
self.assertEqual(content['data'], 'this is my file')
mock_api.api_content_metadata.assert_called_once_with('sha256:240')
mock_service.lookup_content_raw.assert_called_once_with('sha256:240')
@patch('swh.web.ui.views.browse.service')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_relative_dir(self, mock_api, mock_service):
# given
mock_service.lookup_directory_with_path.return_value = {
'sha256': '240',
'target': 'abcd',
'type': 'dir'
}
stub_directory_ls = [
{'type': 'dir',
'target': '123',
'name': 'some-dir-name'},
{'type': 'file',
'sha1': '654',
'name': 'some-filename'},
{'type': 'dir',
'target': '987',
'name': 'some-other-dirname'}
]
mock_api.api_directory.return_value = stub_directory_ls
# when
rv = self.client.get('/browse/directory/sha1/path/to/dir/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('directory.html')
self.assertIsNotNone(self.get_context_variable('files'))
self.assertEqual(len(self.get_context_variable('files')),
len(stub_directory_ls))
mock_api.api_directory.assert_called_once_with('abcd')
@patch('swh.web.ui.views.browse.service')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_relative_not_found(self, mock_api, mock_service):
# given
mock_service.lookup_directory_with_path.side_effect = NotFoundExc(
'Directory entry not found.')
# when
rv = self.client.get('/browse/directory/some-sha1/some/path/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('directory.html')
self.assertEqual(self.get_context_variable('message'),
'Directory entry not found.')
@patch('swh.web.ui.views.browse.api')
@patch('swh.web.ui.views.browse.utils')
@istest
def browse_directory(self, mock_utils, mock_api):
# given
stub_directory_ls = [
{'type': 'dir',
'target': '123',
'name': 'some-dir-name'},
{'type': 'file',
'sha1': '654',
'name': 'some-filename'},
{'type': 'dir',
'target': '987',
'name': 'some-other-dirname'}
]
mock_api.api_directory.return_value = stub_directory_ls
stub_directory_map = [
{'link': '/path/to/url/dir/123',
'name': 'some-dir-name'},
{'link': '/path/to/url/file/654',
'name': 'some-filename'},
{'link': '/path/to/url/dir/987',
'name': 'some-other-dirname'}
]
mock_utils.prepare_data_for_view.return_value = stub_directory_map
# when
rv = self.client.get('/browse/directory/some-sha1/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('directory.html')
self.assertEqual(self.get_context_variable('message'),
'Listing for directory some-sha1:')
self.assertEqual(self.get_context_variable('files'),
stub_directory_map)
mock_api.api_directory.assert_called_once_with(
'some-sha1')
mock_utils.prepare_data_for_view.assert_called_once_with(
stub_directory_ls)
class ContentWithOriginView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
# @istest
def browse_content_with_origin_content_ko_not_found(self, mock_api):
# given
mock_api.api_content_checksum_to_origin.side_effect = NotFoundExc(
'Not found!')
# when
rv = self.client.get('/browse/content/sha256:some-sha256/origin/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content-with-origin.html')
self.assertEqual(self.get_context_variable('message'),
'Not found!')
mock_api.api_content_checksum_to_origin.assert_called_once_with(
'sha256:some-sha256')
@patch('swh.web.ui.views.browse.api')
# @istest
def browse_content_with_origin_ko_bad_input(self, mock_api):
# given
mock_api.api_content_checksum_to_origin.side_effect = BadInputExc(
'Invalid hash')
# when
rv = self.client.get('/browse/content/sha256:some-sha256/origin/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content-with-origin.html')
self.assertEqual(
self.get_context_variable('message'), 'Invalid hash')
mock_api.api_content_checksum_to_origin.assert_called_once_with(
'sha256:some-sha256')
@patch('swh.web.ui.views.browse.api')
# @istest
def browse_content_with_origin(self, mock_api):
# given
mock_api.api_content_checksum_to_origin.return_value = {
'origin_type': 'ftp',
'origin_url': '/some/url',
'revision': 'revision-hash',
'branch': 'master',
'path': '/path/to',
}
# when
rv = self.client.get('/browse/content/sha256:some-sha256/origin/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('content-with-origin.html')
self.assertEqual(
self.get_context_variable('message'),
"The content with hash sha256:some-sha256 has been seen on " +
"origin with type 'ftp'\n" +
"at url '/some/url'. The revision was identified at " +
"'revision-hash' on branch 'master'.\n" +
"The file's path referenced was '/path/to'.")
mock_api.api_content_checksum_to_origin.assert_called_once_with(
'sha256:some-sha256')
class OriginView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_origin_ko_not_found(self, mock_api):
# given
mock_api.api_origin.side_effect = NotFoundExc('Not found!')
# when
rv = self.client.get('/browse/origin/1/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('origin.html')
self.assertEqual(self.get_context_variable('origin_id'), 1)
self.assertEqual(
self.get_context_variable('message'),
'Not found!')
mock_api.api_origin.assert_called_once_with(1)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_origin_ko_bad_input(self, mock_api):
# given
mock_api.api_origin.side_effect = BadInputExc('wrong input')
# when
rv = self.client.get('/browse/origin/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('origin.html')
self.assertEqual(self.get_context_variable('origin_id'), 426)
mock_api.api_origin.assert_called_once_with(426)
@patch('swh.web.ui.views.browse.api')
+ @patch('swh.web.ui.views.browse.url_for')
@istest
- def browse_origin_found(self, mock_api):
+ def browse_origin_found(self, mock_url_for, mock_api):
# given
+ def url_for_test(fn, **args):
+ if fn == 'browse_revision_with_origin':
+ return '/browse/revision/origin/%s/' % args['origin_id']
+ elif fn == 'api_origin_visits':
+ return '/api/1/stat/visits/%s/' % args['origin_id']
+ mock_url_for.side_effect = url_for_test
+
mock_origin = {'type': 'git',
'lister': None,
'project': None,
'url': 'rsync://some/url',
'id': 426}
mock_api.api_origin.return_value = mock_origin
# when
rv = self.client.get('/browse/origin/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('origin.html')
self.assertEqual(self.get_context_variable('origin_id'), 426)
self.assertEqual(self.get_context_variable('origin'), mock_origin)
+ self.assertEqual(self.get_context_variable('browse_url'),
+ '/browse/revision/origin/426/')
+ self.assertEqual(self.get_context_variable('visit_url'),
+ '/api/1/stat/visits/426/')
mock_api.api_origin.assert_called_once_with(426)
class PersonView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_person_ko_not_found(self, mock_api):
# given
mock_api.api_person.side_effect = NotFoundExc('not found')
# when
rv = self.client.get('/browse/person/1/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('person.html')
self.assertEqual(self.get_context_variable('person_id'), 1)
self.assertEqual(
self.get_context_variable('message'),
'not found')
mock_api.api_person.assert_called_once_with(1)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_person_ko_bad_input(self, mock_api):
# given
mock_api.api_person.side_effect = BadInputExc('wrong input')
# when
rv = self.client.get('/browse/person/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('person.html')
self.assertEqual(self.get_context_variable('person_id'), 426)
mock_api.api_person.assert_called_once_with(426)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_person(self, mock_api):
# given
mock_person = {'type': 'git',
'lister': None,
'project': None,
'url': 'rsync://some/url',
'id': 426}
mock_api.api_person.return_value = mock_person
# when
rv = self.client.get('/browse/person/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('person.html')
self.assertEqual(self.get_context_variable('person_id'), 426)
self.assertEqual(self.get_context_variable('person'), mock_person)
mock_api.api_person.assert_called_once_with(426)
class ReleaseView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_release_ko_not_found(self, mock_api):
# given
mock_api.api_release.side_effect = NotFoundExc('not found!')
# when
rv = self.client.get('/browse/release/1/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('release.html')
self.assertEqual(self.get_context_variable('sha1_git'), '1')
self.assertEqual(
self.get_context_variable('message'),
'not found!')
mock_api.api_release.assert_called_once_with('1')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_release_ko_bad_input(self, mock_api):
# given
mock_api.api_release.side_effect = BadInputExc('wrong input')
# when
rv = self.client.get('/browse/release/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('release.html')
self.assertEqual(self.get_context_variable('sha1_git'), '426')
mock_api.api_release.assert_called_once_with('426')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_release(self, mock_api):
# given
self.maxDiff = None
mock_release = {
"date": "Sun, 05 Jul 2015 18:02:06 GMT",
"id": "1e951912027ea6873da6985b91e50c47f645ae1a",
"target": "d770e558e21961ad6cfdf0ff7df0eb5d7d4f0754",
"target_url": '/browse/revision/d770e558e21961ad6cfdf0ff7df0'
'eb5d7d4f0754/',
"synthetic": False,
"target_type": "revision",
"author": {
"email": "torvalds@linux-foundation.org",
"name": "Linus Torvalds"
},
"message": "Linux 4.2-rc1\n",
"name": "v4.2-rc1"
}
mock_api.api_release.return_value = mock_release
expected_release = {
"date": "Sun, 05 Jul 2015 18:02:06 GMT",
"id": "1e951912027ea6873da6985b91e50c47f645ae1a",
"target_url": '/browse/revision/d770e558e21961ad6cfdf0ff7df0'
'eb5d7d4f0754/',
"target": 'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754',
"synthetic": False,
"target_type": "revision",
"author": {
"email": "torvalds@linux-foundation.org",
"name": "Linus Torvalds"
},
"message": "Linux 4.2-rc1\n",
"name": "v4.2-rc1"
}
# when
rv = self.client.get('/browse/release/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('release.html')
self.assertEqual(self.get_context_variable('sha1_git'), '426')
self.assertEqual(self.get_context_variable('release'),
expected_release)
mock_api.api_release.assert_called_once_with('426')
class RevisionView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_ko_not_found(self, mock_api):
# given
mock_api.api_revision.side_effect = NotFoundExc('Not found!')
# when
rv = self.client.get('/browse/revision/1/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('sha1_git'), '1')
self.assertEqual(
self.get_context_variable('message'),
'Not found!')
self.assertIsNone(self.get_context_variable('revision'))
mock_api.api_revision.assert_called_once_with('1', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_ko_bad_input(self, mock_api):
# given
mock_api.api_revision.side_effect = BadInputExc('wrong input!')
# when
rv = self.client.get('/browse/revision/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('sha1_git'), '426')
self.assertEqual(
self.get_context_variable('message'),
'wrong input!')
self.assertIsNone(self.get_context_variable('revision'))
mock_api.api_revision.assert_called_once_with('426', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision(self, mock_api):
# given
stub_revision = {
'id': 'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754',
'date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'committer': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'committer_date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'type': 'git',
'author': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'message': 'Linux 4.2-rc1\n',
'synthetic': False,
'directory_url': '/api/1/directory/'
'2a1dbabeed4dcf1f4a4c441993b2ffc9d972780b/',
'parent_url': [
'/api/1/revision/a585d2b738bfa26326b3f1f40f0f1eda0c067ccf/'
],
}
mock_api.api_revision.return_value = stub_revision
expected_revision = {
'id': 'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754',
'date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'committer': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'committer_date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'type': 'git',
'author': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'message': 'Linux 4.2-rc1\n',
'synthetic': False,
'parent_url': [
'/browse/revision/a585d2b738bfa26326b3f1f40f0f1eda0c067ccf/'
],
'directory_url': '/browse/directory/2a1dbabeed4dcf1f4a4c441993b2f'
'fc9d972780b/',
}
# when
rv = self.client.get('/browse/revision/426/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('sha1_git'), '426')
self.assertEqual(self.get_context_variable('revision'),
expected_revision)
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_revision.assert_called_once_with('426', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_raw_message(self, mock_api):
# given
sha1 = 'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754'
# when
rv = self.client.get('/browse/revision/'
'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754/raw/')
self.assertRedirects(
rv, '/api/1/revision/%s/raw/' % sha1)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_log_ko_not_found(self, mock_api):
# given
mock_api.api_revision_log.side_effect = NotFoundExc('Not found!')
# when
rv = self.client.get('/browse/revision/sha1/log/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-log.html')
self.assertEqual(self.get_context_variable('sha1_git'), 'sha1')
self.assertEqual(
self.get_context_variable('message'),
'Not found!')
self.assertEqual(self.get_context_variable('revisions'), [])
mock_api.api_revision_log.assert_called_once_with('sha1', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_log_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_log.side_effect = BadInputExc('wrong input!')
# when
rv = self.client.get('/browse/revision/426/log/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-log.html')
self.assertEqual(self.get_context_variable('sha1_git'), '426')
self.assertEqual(
self.get_context_variable('message'),
'wrong input!')
self.assertEqual(self.get_context_variable('revisions'), [])
mock_api.api_revision_log.assert_called_once_with('426', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_log(self, mock_api):
# given
stub_revisions = [{
'id': 'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754',
'date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'committer': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'committer_date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'type': 'git',
'author': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'message': 'Linux 4.2-rc1\n',
'synthetic': False,
'directory_url': '/api/1/directory/'
'2a1dbabeed4dcf1f4a4c441993b2ffc9d972780b/',
'parent_url': [
'/api/1/revision/a585d2b738bfa26326b3f1f40f0f1eda0c067ccf/'
],
}]
mock_api.api_revision_log.return_value = stub_revisions
# when
rv = self.client.get('/browse/revision/426/log/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-log.html')
self.assertEqual(self.get_context_variable('sha1_git'), '426')
self.assertTrue(
isinstance(self.get_context_variable('revisions'), map))
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_revision_log.assert_called_once_with('426', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_log_by_ko_not_found(self, mock_api):
# given
mock_api.api_revision_log_by.side_effect = NotFoundExc('Not found!')
# when
rv = self.client.get('/browse/revision/origin/9/log/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-log.html')
self.assertEqual(self.get_context_variable('origin_id'), 9)
self.assertEqual(
self.get_context_variable('message'),
'Not found!')
self.assertEqual(self.get_context_variable('revisions'), [])
mock_api.api_revision_log_by.assert_called_once_with(
9, 'refs/heads/master', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_log_by_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_log.side_effect = BadInputExc('wrong input!')
# when
rv = self.client.get('/browse/revision/abcd/log/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-log.html')
self.assertEqual(self.get_context_variable('sha1_git'), 'abcd')
self.assertEqual(
self.get_context_variable('message'),
'wrong input!')
self.assertEqual(self.get_context_variable('revisions'), [])
mock_api.api_revision_log.assert_called_once_with('abcd', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_log_by(self, mock_api):
# given
stub_revisions = [{
'id': 'd770e558e21961ad6cfdf0ff7df0eb5d7d4f0754',
'date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'committer': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'committer_date': 'Sun, 05 Jul 2015 18:01:52 GMT',
'type': 'git',
'author': {
'email': 'torvalds@linux-foundation.org',
'name': 'Linus Torvalds'
},
'message': 'Linux 4.2-rc1\n',
'synthetic': False,
'directory_url': '/api/1/directory/'
'2a1dbabeed4dcf1f4a4c441993b2ffc9d972780b/',
'parent_url': [
'/api/1/revision/a585d2b738bfa26326b3f1f40f0f1eda0c067ccf/'
],
}]
mock_api.api_revision_log_by.return_value = stub_revisions
# when
rv = self.client.get('/browse/revision/origin/2/log/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-log.html')
self.assertEqual(self.get_context_variable('origin_id'), 2)
self.assertTrue(
isinstance(self.get_context_variable('revisions'), map))
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_revision_log_by.assert_called_once_with(
2, 'refs/heads/master', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_ko_not_found(self, mock_api):
# given
mock_api.api_revision_history.side_effect = NotFoundExc(
'Not found')
# when
rv = self.client.get('/browse/revision/1/history/2/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('sha1_git_root'), '1')
self.assertEqual(self.get_context_variable('sha1_git'), '2')
self.assertEqual(
self.get_context_variable('message'),
'Not found')
mock_api.api_revision_history.assert_called_once_with(
'1', '2')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_history.side_effect = BadInputExc(
'Input incorrect')
# when
rv = self.client.get('/browse/revision/321/history/654/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('sha1_git_root'), '321')
self.assertEqual(self.get_context_variable('sha1_git'), '654')
self.assertEqual(
self.get_context_variable('message'),
'Input incorrect')
mock_api.api_revision_history.assert_called_once_with(
'321', '654')
@istest
def browse_revision_history_ok_same_sha1(self):
# when
rv = self.client.get('/browse/revision/10/history/10/')
# then
self.assertEqual(rv.status_code, 302)
@patch('swh.web.ui.views.browse.utils')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history(self, mock_api, mock_utils):
# given
stub_revision = {'id': 'some-rev'}
mock_api.api_revision_history.return_value = stub_revision
expected_revision = {
'id': 'some-rev-id',
'author': {'name': 'foo', 'email': 'bar'},
'committer': {'name': 'foo', 'email': 'bar'}
}
mock_utils.prepare_data_for_view.return_value = expected_revision
# when
rv = self.client.get('/browse/revision/426/history/789/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('sha1_git_root'), '426')
self.assertEqual(self.get_context_variable('sha1_git'), '789')
self.assertEqual(self.get_context_variable('revision'),
expected_revision)
mock_api.api_revision_history.assert_called_once_with(
'426', '789')
mock_utils.prepare_data_for_view.assert_called_once_with(stub_revision)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory_ko_not_found(self, mock_api):
# given
mock_api.api_revision_directory.side_effect = NotFoundExc('Not found!')
# when
rv = self.client.get('/browse/revision/1/directory/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('sha1_git'), '1')
self.assertEqual(self.get_context_variable('path'), '.')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(
self.get_context_variable('message'),
"Not found!")
mock_api.api_revision_directory.assert_called_once_with(
'1', None, with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_directory.side_effect = BadInputExc('Bad input!')
# when
rv = self.client.get('/browse/revision/10/directory/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('sha1_git'), '10')
self.assertEqual(self.get_context_variable('path'), '.')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(
self.get_context_variable('message'),
"Bad input!")
mock_api.api_revision_directory.assert_called_once_with(
'10', None, with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory(self, mock_api):
# given
stub_result0 = {
'type': 'dir',
'revision': '100',
'content': [
{
'id': 'some-result',
'type': 'file',
'name': 'blah',
},
{
'id': 'some-other-result',
'type': 'dir',
'name': 'foo',
}
]
}
mock_api.api_revision_directory.return_value = stub_result0
stub_result1 = {
'type': 'dir',
'revision': '100',
'content':
[
{
'id': 'some-result',
'type': 'file',
'name': 'blah',
},
{
'id': 'some-other-result',
'type': 'dir',
'name': 'foo',
}
]
}
# when
rv = self.client.get('/browse/revision/100/directory/some/path/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('sha1_git'), '100')
self.assertEqual(self.get_context_variable('revision'), '100')
self.assertEqual(self.get_context_variable('path'), 'some/path')
self.assertIsNone(self.get_context_variable('message'))
self.assertEqual(self.get_context_variable('result'), stub_result1)
mock_api.api_revision_directory.assert_called_once_with(
'100', 'some/path', with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_directory_ko_not_found(self, mock_api):
# given
mock_api.api_revision_history_directory.side_effect = NotFoundExc(
'not found')
# when
rv = self.client.get('/browse/revision/123/history/456/directory/a/b/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('sha1_git_root'), '123')
self.assertEqual(self.get_context_variable('sha1_git'), '456')
self.assertEqual(self.get_context_variable('path'), 'a/b')
self.assertEqual(self.get_context_variable('message'), 'not found')
self.assertIsNone(self.get_context_variable('result'))
mock_api.api_revision_history_directory.assert_called_once_with(
'123', '456', 'a/b', with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_directory_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_history_directory.side_effect = BadInputExc(
'bad input')
# when
rv = self.client.get('/browse/revision/123/history/456/directory/a/c/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('sha1_git_root'), '123')
self.assertEqual(self.get_context_variable('sha1_git'), '456')
self.assertEqual(self.get_context_variable('path'), 'a/c')
self.assertEqual(self.get_context_variable('message'), 'bad input')
self.assertIsNone(self.get_context_variable('result'))
mock_api.api_revision_history_directory.assert_called_once_with(
'123', '456', 'a/c', with_data=True)
@patch('swh.web.ui.views.browse.service')
@istest
def browse_revision_history_directory_ok_no_trailing_slash_so_redirect(
self, mock_service):
# when
rv = self.client.get('/browse/revision/1/history/2/directory/path/to')
# then
self.assertEqual(rv.status_code, 301)
@patch('swh.web.ui.views.browse.service')
@istest
def browse_revision_history_directory_ok_same_sha1_redirects(
self, mock_service):
# when
rv = self.client.get('/browse/revision/1/history/1/directory/path/to')
# then
self.assertEqual(rv.status_code, 301)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_directory(self, mock_api):
# given
stub_result0 = {
'type': 'dir',
'revision': '1000',
'content': [{
'id': 'some-result',
'type': 'file',
'name': 'blah'
}]
}
mock_api.api_revision_history_directory.return_value = stub_result0
stub_result1 = {
'type': 'dir',
'revision': '1000',
'content': [{
'id': 'some-result',
'type': 'file',
'name': 'blah'
}]
}
# when
rv = self.client.get('/browse/revision/100/history/999/directory/'
'path/to/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('sha1_git_root'), '100')
self.assertEqual(self.get_context_variable('sha1_git'), '999')
self.assertEqual(self.get_context_variable('revision'), '1000')
self.assertEqual(self.get_context_variable('path'), 'path/to')
self.assertIsNone(self.get_context_variable('message'))
self.assertEqual(self.get_context_variable('result'), stub_result1)
mock_api.api_revision_history_directory.assert_called_once_with(
'100', '999', 'path/to', with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_through_origin_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_history_through_origin.side_effect = BadInputExc(
'Problem input.') # noqa
# when
rv = self.client.get('/browse/revision/origin/99'
'/history/123/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertIsNone(self.get_context_variable('revision'))
self.assertEqual(self.get_context_variable('message'),
'Problem input.')
mock_api.api_revision_history_through_origin.assert_called_once_with(
99, 'refs/heads/master', None, '123')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_through_origin_ko_not_found(self, mock_api):
# given
mock_api.api_revision_history_through_origin.side_effect = NotFoundExc(
'Not found.')
# when
rv = self.client.get('/browse/revision/origin/999/'
'branch/dev/history/123/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertIsNone(self.get_context_variable('revision'))
self.assertEqual(self.get_context_variable('message'),
'Not found.')
mock_api.api_revision_history_through_origin.assert_called_once_with(
999, 'dev', None, '123')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_through_origin_ko_other_error(self, mock_api):
# given
mock_api.api_revision_history_through_origin.side_effect = ValueError(
'Other Error.')
# when
rv = self.client.get('/browse/revision/origin/438'
'/branch/scratch'
'/ts/2016'
'/history/789/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertIsNone(self.get_context_variable('revision'))
self.assertEqual(self.get_context_variable('message'),
'Other Error.')
mock_api.api_revision_history_through_origin.assert_called_once_with(
438, 'scratch', '2016', '789')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_history_through_origin(self, mock_api):
# given
stub_rev = {
'id': 'some-id',
'author': {},
'committer': {}
}
mock_api.api_revision_history_through_origin.return_value = stub_rev
# when
rv = self.client.get('/browse/revision/origin/99/history/123/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('revision'), stub_rev)
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_revision_history_through_origin.assert_called_once_with(
99, 'refs/heads/master', None, '123')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_with_origin_ko_not_found(self, mock_api):
# given
mock_api.api_revision_with_origin.side_effect = NotFoundExc(
'Not found')
# when
rv = self.client.get('/browse/revision/origin/1/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertIsNone(self.get_context_variable('revision'))
self.assertEqual(self.get_context_variable('message'), 'Not found')
mock_api.api_revision_with_origin.assert_called_once_with(
1, 'refs/heads/master', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_with_origin_ko_bad_input(self, mock_api):
# given
mock_api.api_revision_with_origin.side_effect = BadInputExc(
'Bad Input')
# when
rv = self.client.get('/browse/revision/origin/1000/branch/dev/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertIsNone(self.get_context_variable('revision'))
self.assertEqual(self.get_context_variable('message'), 'Bad Input')
mock_api.api_revision_with_origin.assert_called_once_with(
1000, 'dev', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_with_origin_ko_other(self, mock_api):
# given
mock_api.api_revision_with_origin.side_effect = ValueError(
'Other')
# when
rv = self.client.get('/browse/revision/origin/1999'
'/branch/scratch/master'
'/ts/1990-01-10/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertIsNone(self.get_context_variable('revision'))
self.assertEqual(self.get_context_variable('message'), 'Other')
mock_api.api_revision_with_origin.assert_called_once_with(
1999, 'scratch/master', '1990-01-10')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_with_origin(self, mock_api):
# given
stub_rev = {'id': 'some-id',
'author': {},
'committer': {}}
mock_api.api_revision_with_origin.return_value = stub_rev
# when
rv = self.client.get('/browse/revision/origin/1/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision.html')
self.assertEqual(self.get_context_variable('revision'), stub_rev)
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_revision_with_origin.assert_called_once_with(
1, 'refs/heads/master', None)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory_through_origin_ko_not_found(self, mock_api):
# given
mock_api.api_directory_through_revision_origin.side_effect = BadInputExc( # noqa
'this is not the robot you are looking for')
# when
rv = self.client.get('/browse/revision/origin/2'
'/directory/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(self.get_context_variable('message'),
'this is not the robot you are looking for')
mock_api.api_directory_through_revision_origin.assert_called_once_with( # noqa
2, 'refs/heads/master', None, None, with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory_through_origin_ko_bad_input(self, mock_api):
# given
mock_api.api_directory_through_revision_origin.side_effect = BadInputExc( # noqa
'Bad Robot')
# when
rv = self.client.get('/browse/revision/origin/2'
'/directory/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(self.get_context_variable('message'), 'Bad Robot')
mock_api.api_directory_through_revision_origin.assert_called_once_with(
2, 'refs/heads/master', None, None, with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory_through_origin_ko_other(self, mock_api):
# given
mock_api.api_directory_through_revision_origin.side_effect = ValueError( # noqa
'Other bad stuff')
# when
rv = self.client.get('/browse/revision/origin/2'
'/directory/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(self.get_context_variable('message'),
'Other bad stuff')
mock_api.api_directory_through_revision_origin.assert_called_once_with(
2, 'refs/heads/master', None, None, with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_revision_directory_through_origin(self, mock_api):
# given
stub_res = {'id': 'some-id',
'revision': 'some-rev-id',
'type': 'dir',
'content': 'some-content'}
mock_api.api_directory_through_revision_origin.return_value = stub_res
# when
rv = self.client.get('/browse/revision/origin/2'
'/branch/dev'
'/ts/2013-20-20 10:02'
'/directory/some/file/')
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('result'), stub_res)
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_directory_through_revision_origin.assert_called_once_with(
2, 'dev', '2013-20-20 10:02', 'some/file', with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_through_revision_with_origin_history_ko_not_found(
self, mock_api):
mock_api.api_directory_through_revision_with_origin_history.side_effect = NotFoundExc( # noqa
'Not found!')
# when
rv = self.client.get('/browse/revision/origin/987'
'/history/sha1git'
'/directory/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(self.get_context_variable('message'), 'Not found!')
self.assertEqual(self.get_context_variable('path'), '.')
mock_api.api_directory_through_revision_with_origin_history.assert_called_once_with( # noqa
987, 'refs/heads/master', None, 'sha1git', None, with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_through_revision_with_origin_history_ko_bad_input(
self, mock_api):
mock_api.api_directory_through_revision_with_origin_history.side_effect = BadInputExc( # noqa
'Bad input! Bleh!')
# when
rv = self.client.get('/browse/revision/origin/798'
'/branch/refs/heads/dev'
'/ts/2012-11-11'
'/history/1234'
'/directory/some/path/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertIsNone(self.get_context_variable('result'))
self.assertEqual(self.get_context_variable('message'),
'Bad input! Bleh!')
self.assertEqual(self.get_context_variable('path'), 'some/path')
mock_api.api_directory_through_revision_with_origin_history.assert_called_once_with( # noqa
798, 'refs/heads/dev', '2012-11-11', '1234', 'some/path',
with_data=True)
@patch('swh.web.ui.views.browse.api')
@istest
def browse_directory_through_revision_with_origin_history(
self, mock_api):
stub_dir = {'type': 'dir',
'content': [],
'revision': 'specific-rev-id'}
mock_api.api_directory_through_revision_with_origin_history.return_value = stub_dir # noqa
# when
rv = self.client.get('/browse/revision/origin/101010'
'/ts/1955-11-12'
'/history/54628'
'/directory/emacs-24.5/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('revision-directory.html')
self.assertEqual(self.get_context_variable('result'), stub_dir)
self.assertIsNone(self.get_context_variable('message'))
self.assertEqual(self.get_context_variable('path'), 'emacs-24.5')
mock_api.api_directory_through_revision_with_origin_history.assert_called_once_with( # noqa
101010, 'refs/heads/master', '1955-11-12', '54628', 'emacs-24.5',
with_data=True)
class EntityView(test_app.SWHViewTestCase):
render_template = False
@patch('swh.web.ui.views.browse.api')
@istest
def browse_entity_ko_not_found(self, mock_api):
# given
mock_api.api_entity_by_uuid.side_effect = NotFoundExc('Not found!')
# when
rv = self.client.get('/browse/entity/'
'5f4d4c51-498a-4e28-88b3-b3e4e8396cba/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('entity.html')
self.assertEqual(self.get_context_variable('entities'), [])
self.assertEqual(self.get_context_variable('message'), 'Not found!')
mock_api.api_entity_by_uuid.assert_called_once_with(
'5f4d4c51-498a-4e28-88b3-b3e4e8396cba')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_entity_ko_bad_input(self, mock_api):
# given
mock_api.api_entity_by_uuid.side_effect = BadInputExc('wrong input!')
# when
rv = self.client.get('/browse/entity/blah-blah-uuid/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('entity.html')
self.assertEqual(self.get_context_variable('entities'), [])
self.assertEqual(self.get_context_variable('message'), 'wrong input!')
mock_api.api_entity_by_uuid.assert_called_once_with(
'blah-blah-uuid')
@patch('swh.web.ui.views.browse.api')
@istest
def browse_entity(self, mock_api):
# given
stub_entities = [
{'id': '5f4d4c51-5a9b-4e28-88b3-b3e4e8396cba'}]
mock_api.api_entity_by_uuid.return_value = stub_entities
# when
rv = self.client.get('/browse/entity/'
'5f4d4c51-5a9b-4e28-88b3-b3e4e8396cba/')
# then
self.assertEqual(rv.status_code, 200)
self.assert_template_used('entity.html')
self.assertEqual(self.get_context_variable('entities'), stub_entities)
self.assertIsNone(self.get_context_variable('message'))
mock_api.api_entity_by_uuid.assert_called_once_with(
'5f4d4c51-5a9b-4e28-88b3-b3e4e8396cba')
diff --git a/swh/web/ui/views/browse.py b/swh/web/ui/views/browse.py
index 376d1251..55a49c1b 100644
--- a/swh/web/ui/views/browse.py
+++ b/swh/web/ui/views/browse.py
@@ -1,847 +1,853 @@
# Copyright (C) 2015 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from encodings.aliases import aliases
from flask import render_template, request, url_for, redirect
from flask.ext.api.decorators import set_renderers
from flask.ext.api.renderers import HTMLRenderer
from swh.core.hashutil import ALGORITHMS
from .. import service, utils
from ..exc import BadInputExc, NotFoundExc
from ..main import app
from . import api
hash_filter_keys = ALGORITHMS
@app.route('/search/', methods=['GET', 'POST'])
@set_renderers(HTMLRenderer)
def search():
"""Search for hashes in swh-storage.
One form to submit either:
- hash query to look up in swh storage
- file hashes calculated client-side to be queried in swh storage
- both
Returns:
dict representing data to look for in swh storage.
The following keys are returned:
- search_stats: {'nbfiles': X, 'pct': Y} the number of total
queried files and percentage of files not in storage respectively
- responses: array of {'filename': X, 'sha1': Y, 'found': Z}
- messages: General messages.
TODO:
Batch-process with all checksums, not just sha1
"""
env = {'search_res': None,
'search_stats': None,
'message': []}
search_stats = {'nbfiles': 0, 'pct': 0}
search_res = None
message = ''
# Get with a single hash request
if request.method == 'GET':
data = request.args
q = data.get('q')
if q:
try:
search = api.api_search(q)
search_res = search['search_res']
search_stats = search['search_stats']
except BadInputExc as e:
message = str(e)
# Post form submission with many hash requests
elif request.method == 'POST':
try:
search = api.api_search(None)
search_res = search['search_res']
search_stats = search['search_stats']
except BadInputExc as e:
message = str(e)
env['search_stats'] = search_stats
env['search_res'] = search_res
env['message'] = message
return render_template('upload_and_search.html', **env)
@app.route('/browse/content/')
@app.route('/browse/content//')
@set_renderers(HTMLRenderer)
def browse_content(q):
"""Given a hash and a checksum, display the content's meta-data.
Args:
q is of the form algo_hash:hash with algo_hash in
(sha1, sha1_git, sha256)
Returns:
Information on one possible origin for such content.
Raises:
BadInputExc in case of unknown algo_hash or bad hash
NotFoundExc if the content is not found.
"""
env = {'q': q,
'message': None,
'content': None}
encoding = request.args.get('encoding', 'utf8')
if encoding not in aliases:
env['message'] = 'Encoding %s not supported.' \
'Supported Encodings: %s' % (
encoding, list(aliases.keys()))
return render_template('content.html', **env)
try:
content = api.api_content_metadata(q)
content_raw = service.lookup_content_raw(q)
if content_raw:
content['data'] = content_raw['data']
env['content'] = utils.prepare_data_for_view(content,
encoding=encoding)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('content.html', **env)
@app.route('/browse/content//raw/')
def browse_content_raw(q):
"""Given a hash and a checksum, display the content's raw data.
Args:
q is of the form algo_hash:hash with algo_hash in
(sha1, sha1_git, sha256)
Returns:
Information on one possible origin for such content.
Raises:
BadInputExc in case of unknown algo_hash or bad hash
NotFoundExc if the content is not found.
"""
return redirect(url_for('api_content_raw', q=q))
def _origin_seen(q, data):
"""Given an origin, compute a message string with the right information.
Args:
origin: a dictionary with keys:
- origin: a dictionary with type and url keys
- occurrence: a dictionary with a validity range
Returns:
Message as a string
"""
origin_type = data['origin_type']
origin_url = data['origin_url']
revision = data['revision']
branch = data['branch']
path = data['path']
return """The content with hash %s has been seen on origin with type '%s'
at url '%s'. The revision was identified at '%s' on branch '%s'.
The file's path referenced was '%s'.""" % (q,
origin_type,
origin_url,
revision,
branch,
path)
# @app.route('/browse/content//origin/')
@set_renderers(HTMLRenderer)
def browse_content_with_origin(q):
"""Show content information.
Args:
- q: query string of the form with
`algo_hash` in sha1, sha1_git, sha256.
This means that several different URLs (at least one per
HASH_ALGO) will point to the same content sha: the sha with
'hash' format
Returns:
The content's information at for a given checksum.
"""
env = {'q': q}
try:
origin = api.api_content_checksum_to_origin(q)
message = _origin_seen(q, origin)
except (NotFoundExc, BadInputExc) as e:
message = str(e)
env['message'] = message
return render_template('content-with-origin.html', **env)
@app.route('/browse/directory/')
@app.route('/browse/directory//')
@app.route('/browse/directory///')
@set_renderers(HTMLRenderer)
def browse_directory(sha1_git, path=None):
"""Show directory information.
Args:
- sha1_git: the directory's sha1 git identifier. If path
is set, the base directory for the relative path to the entry
- path: the path to the requested entry, relative to
the directory pointed by sha1_git
Returns:
The content's information at sha1_git, or at sha1_git/path if
path is set.
"""
env = {'sha1_git': sha1_git,
'files': []}
try:
if path:
env['message'] = ('Listing for directory with path %s from %s:'
% (path, sha1_git))
dir_or_file = service.lookup_directory_with_path(
sha1_git, path)
if dir_or_file['type'] == 'file':
fsha = 'sha256:%s' % dir_or_file['sha256']
content = api.api_content_metadata(fsha)
content_raw = service.lookup_content_raw(fsha)
if content_raw: # FIXME: currently assuming utf8 encoding
content['data'] = content_raw['data']
env['content'] = utils.prepare_data_for_view(
content, encoding='utf-8')
return render_template('content.html', **env)
else:
directory_files = api.api_directory(dir_or_file['target'])
env['files'] = utils.prepare_data_for_view(directory_files)
else:
env['message'] = "Listing for directory %s:" % sha1_git
directory_files = api.api_directory(sha1_git)
env['files'] = utils.prepare_data_for_view(directory_files)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('directory.html', **env)
@app.route('/browse/origin/')
@app.route('/browse/origin//')
@set_renderers(HTMLRenderer)
def browse_origin(origin_id):
"""Browse origin with id id.
"""
- env = {'origin_id': origin_id,
+
+ browse_url = url_for('browse_revision_with_origin', origin_id=origin_id)
+ visit_url = url_for('api_origin_visits', origin_id=origin_id)
+
+ env = {'browse_url': browse_url,
+ 'visit_url': visit_url,
+ 'origin_id': origin_id,
'origin': None}
try:
env['origin'] = api.api_origin(origin_id)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('origin.html', **env)
@app.route('/browse/person/')
@app.route('/browse/person//')
@set_renderers(HTMLRenderer)
def browse_person(person_id):
"""Browse person with id id.
"""
env = {'person_id': person_id,
'person': None,
'message': None}
try:
env['person'] = api.api_person(person_id)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('person.html', **env)
@app.route('/browse/release/')
@app.route('/browse/release//')
@set_renderers(HTMLRenderer)
def browse_release(sha1_git):
"""Browse release with sha1_git.
"""
env = {'sha1_git': sha1_git,
'message': None,
'release': None}
try:
rel = api.api_release(sha1_git)
env['release'] = utils.prepare_data_for_view(rel)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('release.html', **env)
@app.route('/browse/revision/')
@app.route('/browse/revision//')
@app.route('/browse/revision//prev//')
@set_renderers(HTMLRenderer)
def browse_revision(sha1_git, prev_sha1s=None):
"""Browse the revision with git SHA1 sha1_git_cur, while optionally keeping
the context from which we came as a list of previous (i.e. later)
revisions' sha1s.
Args:
sha1_git: the requested revision's sha1_git.
prev_sha1s: an optional string of /-separated sha1s representing our
context, ordered by descending revision date.
Returns:
Information about revision of git SHA1 sha1_git_cur, with relevant URLS
pointing to the context augmented with sha1_git_cur.
Example:
GET /browse/revision/
"""
env = {'sha1_git': sha1_git,
'message': None,
'revision': None}
try:
rev = api.api_revision(sha1_git, prev_sha1s)
env['revision'] = utils.prepare_data_for_view(rev)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('revision.html', **env)
@app.route('/browse/revision//raw/')
def browse_revision_raw_message(sha1_git):
"""Given a sha1_git, display the corresponding revision's raw message.
"""
return redirect(url_for('api_revision_raw_message', sha1_git=sha1_git))
@app.route('/browse/revision//log/')
@app.route('/browse/revision//prev//log/')
@set_renderers(HTMLRenderer)
def browse_revision_log(sha1_git, prev_sha1s=None):
"""Browse revision with sha1_git's log. If the navigation path through the
commit tree is specified, we intersect the earliest revision's log with the
revisions the user browsed through - ie the path taken to the specified
revision.
Args:
sha1_git: the current revision's SHA1_git checksum
prev_sha1s: optionally, the path through which we want log information
"""
env = {'sha1_git': sha1_git,
'sha1_url': '/browse/revision/%s/' % sha1_git,
'message': None,
'revisions': []}
try:
revisions = api.api_revision_log(sha1_git, prev_sha1s)
env['revisions'] = map(utils.prepare_data_for_view, revisions)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('revision-log.html', **env)
@app.route('/browse/revision'
'/origin/log/')
@app.route('/browse/revision'
'/origin//log/')
@app.route('/browse/revision'
'/origin/'
'/branch//log/')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts//log/')
@app.route('/browse/revision'
'/origin/'
'/ts//log/')
@set_renderers(HTMLRenderer)
def browse_revision_log_by(origin_id,
branch_name='refs/heads/master',
timestamp=None):
"""Browse the revision described by origin, branch name and timestamp's
log
Args:
origin_id: the revision's origin
branch_name: the revision's branch
timestamp: the requested timeframe for the revision
Returns:
The revision log of the described revision as a list of revisions
if it is found.
"""
env = {'sha1_git': None,
'origin_id': origin_id,
'origin_url': '/browse/origin/%d/' % origin_id,
'branch_name': branch_name,
'timestamp': timestamp,
'message': None,
'revisions': []}
try:
revisions = api.api_revision_log_by(
origin_id, branch_name, timestamp)
env['revisions'] = map(utils.prepare_data_for_view, revisions)
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('revision-log.html', **env)
@app.route('/browse/revision//prev//')
@set_renderers(HTMLRenderer)
def browse_with_rev_context(sha1_git_cur, sha1s):
"""Browse the revision with git SHA1 sha1_git_cur, while keeping the context
from which we came as a list of previous (i.e. later) revisions' sha1s.
Args:
sha1_git_cur: the requested revision's sha1_git.
sha1s: a string of /-separated sha1s representing our context, ordered
by descending revision date.
Returns:
Information about revision of git SHA1 sha1_git_cur, with relevant URLS
pointing to the context augmented with sha1_git_cur.
Example:
GET /browse/revision/
"""
env = {'sha1_git': sha1_git_cur,
'message': None,
'revision': None}
try:
revision = api.api_revision(
sha1_git_cur, sha1s)
env['revision'] = utils.prepare_data_for_view(revision)
except (BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision.html', **env)
@app.route('/browse/revision//history//')
@set_renderers(HTMLRenderer)
def browse_revision_history(sha1_git_root, sha1_git):
"""Display information about revision sha1_git, limited to the
sub-graph of all transitive parents of sha1_git_root.
In other words, sha1_git is an ancestor of sha1_git_root.
Args:
sha1_git_root: latest revision of the browsed history.
sha1_git: one of sha1_git_root's ancestors.
limit: optional query parameter to limit the revisions log
(default to 100). For now, note that this limit could impede the
transitivity conclusion about sha1_git not being an ancestor of
sha1_git_root (even if it is).
Returns:
Information on sha1_git if it is an ancestor of sha1_git_root
including children leading to sha1_git_root.
"""
env = {'sha1_git_root': sha1_git_root,
'sha1_git': sha1_git,
'message': None,
'keys': [],
'revision': None}
if sha1_git == sha1_git_root:
return redirect(url_for('browse_revision',
sha1_git=sha1_git))
try:
revision = api.api_revision_history(sha1_git_root,
sha1_git)
env['revision'] = utils.prepare_data_for_view(revision)
except (BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision.html', **env)
@app.route('/browse/revision//directory/')
@app.route('/browse/revision//directory//')
@set_renderers(HTMLRenderer)
def browse_revision_directory(sha1_git, path=None):
"""Browse directory from revision with sha1_git.
"""
env = {
'sha1_git': sha1_git,
'path': '.' if not path else path,
'message': None,
'result': None
}
encoding = request.args.get('encoding', 'utf8')
if encoding not in aliases:
env['message'] = 'Encoding %s not supported.' \
'Supported Encodings: %s' % (
encoding, list(aliases.keys()))
return render_template('revision-directory.html', **env)
try:
result = api.api_revision_directory(sha1_git, path, with_data=True)
result['content'] = utils.prepare_data_for_view(result['content'],
encoding=encoding)
env['revision'] = result['revision']
env['result'] = result
except (BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision-directory.html', **env)
@app.route('/browse/revision/'
'/history/'
'/directory/')
@app.route('/browse/revision/'
'/history/'
'/directory//')
@set_renderers(HTMLRenderer)
def browse_revision_history_directory(sha1_git_root, sha1_git, path=None):
"""Return information about directory pointed to by the revision
defined as: revision sha1_git, limited to the sub-graph of all
transitive parents of sha1_git_root.
Args:
sha1_git_root: latest revision of the browsed history.
sha1_git: one of sha1_git_root's ancestors.
path: optional directory pointed to by that revision.
limit: optional query parameter to limit the revisions log
(default to 100). For now, note that this limit could impede the
transitivity conclusion about sha1_git not being an ancestor of
sha1_git_root (even if it is).
Returns:
Information on the directory pointed to by that revision.
Raises:
BadInputExc in case of unknown algo_hash or bad hash.
NotFoundExc if either revision is not found or if sha1_git is not an
ancestor of sha1_git_root or the path referenced does not exist
"""
env = {
'sha1_git_root': sha1_git_root,
'sha1_git': sha1_git,
'path': '.' if not path else path,
'message': None,
'result': None
}
encoding = request.args.get('encoding', 'utf8')
if encoding not in aliases:
env['message'] = 'Encoding %s not supported.' \
'Supported Encodings: %s' % (
encoding, list(aliases.keys()))
return render_template('revision-directory.html', **env)
if sha1_git == sha1_git_root:
return redirect(url_for('browse_revision_directory',
sha1_git=sha1_git,
path=path,
encoding=encoding),
code=301)
try:
result = api.api_revision_history_directory(sha1_git_root,
sha1_git,
path,
with_data=True)
env['revision'] = result['revision']
env['content'] = utils.prepare_data_for_view(result['content'],
encoding=encoding)
env['result'] = result
except (BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision-directory.html', **env)
@app.route('/browse/revision'
'/origin/'
'/history/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/history/'
'/directory//')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/history/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/history/'
'/directory//')
@app.route('/browse/revision'
'/origin/'
'/ts/'
'/history/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/ts/'
'/history/'
'/directory//')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts/'
'/history/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts/'
'/history/'
'/directory//')
@set_renderers(HTMLRenderer)
def browse_directory_through_revision_with_origin_history(
origin_id,
branch_name="refs/heads/master",
ts=None,
sha1_git=None,
path=None):
env = {
'origin_id': origin_id,
'branch_name': branch_name,
'ts': ts,
'sha1_git': sha1_git,
'path': '.' if not path else path,
'message': None,
'result': None
}
encoding = request.args.get('encoding', 'utf8')
if encoding not in aliases:
env['message'] = (('Encoding %s not supported.'
'Supported Encodings: %s') % (
encoding, list(aliases.keys())))
return render_template('revision-directory.html', **env)
try:
result = api.api_directory_through_revision_with_origin_history(
origin_id, branch_name, ts, sha1_git, path, with_data=True)
env['revision'] = result['revision']
env['content'] = utils.prepare_data_for_view(result['content'],
encoding=encoding)
env['result'] = result
except (BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision-directory.html', **env)
@app.route('/browse/revision'
'/origin/')
@app.route('/browse/revision'
'/origin//')
@app.route('/browse/revision'
'/origin/'
'/branch//')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts//')
@app.route('/browse/revision'
'/origin/'
'/ts//')
@set_renderers(HTMLRenderer)
def browse_revision_with_origin(origin_id,
branch_name="refs/heads/master",
ts=None):
"""Instead of having to specify a (root) revision by SHA1_GIT, users
might want to specify a place and a time. In SWH a "place" is an
origin; a "time" is a timestamp at which some place has been
observed by SWH crawlers.
Args:
origin_id: origin's identifier (default to 1).
branch_name: the optional branch for the given origin (default
to master).
timestamp: optional timestamp (default to the nearest time
crawl of timestamp).
Returns:
Information on the revision if found.
Raises:
BadInputExc in case of unknown algo_hash or bad hash.
NotFoundExc if the revision is not found.
"""
env = {'message': None,
'revision': None}
try:
revision = api.api_revision_with_origin(origin_id,
branch_name,
ts)
env['revision'] = utils.prepare_data_for_view(revision)
except (ValueError, NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('revision.html', **env)
@app.route('/browse/revision'
'/origin/'
'/history//')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/history//')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts/'
'/history//')
@set_renderers(HTMLRenderer)
def browse_revision_history_through_origin(origin_id,
branch_name='refs/heads/master',
ts=None,
sha1_git=None):
"""Return information about revision sha1_git, limited to the
sub-graph of all transitive parents of the revision root identified
by (origin_id, branch_name, ts).
Given sha1_git_root such root revision's identifier, in other words,
sha1_git is an ancestor of sha1_git_root.
Args:
origin_id: origin's identifier (default to 1).
branch_name: the optional branch for the given origin (default
to master).
timestamp: optional timestamp (default to the nearest time
crawl of timestamp).
sha1_git: one of sha1_git_root's ancestors.
limit: optional query parameter to limit the revisions log
(default to 100). For now, note that this limit could impede the
transitivity conclusion about sha1_git not being an ancestor of
sha1_git_root (even if it is).
Returns:
Information on sha1_git if it is an ancestor of sha1_git_root
including children leading to sha1_git_root.
"""
env = {'message': None,
'revision': None}
try:
revision = api.api_revision_history_through_origin(
origin_id,
branch_name,
ts,
sha1_git)
env['revision'] = utils.prepare_data_for_view(revision)
except (ValueError, BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision.html', **env)
@app.route('/browse/revision'
'/origin/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/directory//')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts/'
'/directory/')
@app.route('/browse/revision'
'/origin/'
'/branch/'
'/ts/'
'/directory//')
@set_renderers(HTMLRenderer)
def browse_revision_directory_through_origin(origin_id,
branch_name='refs/heads/master',
ts=None,
path=None):
env = {'message': None,
'origin_id': origin_id,
'ts': ts,
'path': '.' if not path else path,
'result': None}
encoding = request.args.get('encoding', 'utf8')
if encoding not in aliases:
env['message'] = 'Encoding %s not supported.' \
'Supported Encodings: %s' % (
encoding, list(aliases.keys()))
return render_template('revision-directory.html', **env)
try:
result = api.api_directory_through_revision_origin(
origin_id,
branch_name,
ts,
path,
with_data=True)
result['content'] = utils.prepare_data_for_view(result['content'],
encoding=encoding)
env['revision'] = result['revision']
env['result'] = result
except (ValueError, BadInputExc, NotFoundExc) as e:
env['message'] = str(e)
return render_template('revision-directory.html', **env)
@app.route('/browse/entity/')
@app.route('/browse/entity//')
@set_renderers(HTMLRenderer)
def browse_entity(uuid):
env = {'entities': [],
'message': None}
try:
entities = api.api_entity_by_uuid(uuid)
env['entities'] = entities
except (NotFoundExc, BadInputExc) as e:
env['message'] = str(e)
return render_template('entity.html', **env)