Merge pull request #95 from EverythingMe/feature_stacking_selection

Allow user to set the stacking of the chart.

.env.example

@@ -0,0 +1,9 @@
+REDASH_CONNECTION_ADAPTER=pg
+REDASH_CONNECTION_STRING="dbname=data"
+REDASH_STATIC_ASSETS_PATH=../rd_ui/app/
+REDASH_GOOGLE_APPS_DOMAIN=
+REDASH_ADMINS=
+REDASH_WORKERS_COUNT=2
+REDASH_COOKIE_SECRET=
+REDASH_DATABASE_URL='postgresql://rd'
+REDASH_LOG_LEVEL = "INFO"

.gitignore

@@ -2,7 +2,6 @@
 .idea
 *.pyc
 .coverage
-redash/settings.py
 rd_ui/dist
 .DS_Store
 
@@ -10,3 +9,4 @@ rd_ui/dist
 .vagrant
 Berksfile.lock
 redash/dump.rdb
+.env

Honchofile

@@ -0,0 +1,2 @@
+web: ./manage.py runserver -p $PORT
+worker: ./manage.py runworkers

Procfile

@@ -0,0 +1 @@
+web: honcho start -f Honchofile -p $PORT

circle.yml

@@ -10,7 +10,6 @@ dependencies:
     - make deps
     - pip install requests coverage nose
     - pip install -r requirements.txt
-    - cp redash/settings_example.py redash/settings.py
   cache_directories:
     - rd_ui/node_modules/
     - rd_ui/app/bower_components/
@@ -18,7 +17,6 @@ test:
   override:
     - make test
   post:
-    - rm redash/settings.py
     - make pack 
 deployment:
   github:

manage.py

@@ -20,6 +20,7 @@ def version():
     """Displays re:dash version."""
     print __version__
 
+
 @manager.command
 def runworkers():
     """Starts the re:dash query executors/workers."""
@@ -65,4 +66,8 @@ def drop_tables():
 manager.add_command("database", database_manager)
 
 if __name__ == '__main__':
+    channel = logging.StreamHandler()
+    logging.getLogger().addHandler(channel)
+    logging.getLogger().setLevel(settings.LOG_LEVEL)
+
     manager.run()

migrations/create_visualizations.py

@@ -4,7 +4,7 @@ from redash import db
 from redash import models
 
 if __name__ == '__main__':
-    default_options = {"series": {"type": "bar"}}
+    default_options = {"series": {"type": "column"}}
 
     db.connect_db()
 

rd_ui/app/scripts/controllers.js

@@ -20,8 +20,9 @@
             });
         };
 
-        $scope.open = function(query) {
+        $scope.open = function(query, visualization) {
             $location.path('/queries/' + query.id);
+            $location.hash(visualization.id);
         }
 
         $scope.query = new Query($scope.widget.visualization.query);
@@ -112,6 +113,9 @@
                     } else {
                         // TODO: replace this with a safer method
                         $location.path($location.path().replace(oldId, q.id)).replace();
+
+                        // Reset visualizations tab to table after duplicating a query:
+                        $location.hash('table');
                     }
                 }
             }, function(httpResponse) {

rd_ui/app/scripts/directives.js

@@ -62,11 +62,21 @@
                     'Cohort': Visualization.prototype.TYPES.COHORT
                 };
                 scope.seriesTypes = {
-                    'Line': Visualization.prototype.SERIES_TYPES.LINE,
-                    'Bar': Visualization.prototype.SERIES_TYPES.BAR,
-                    'Area': Visualization.prototype.SERIES_TYPES.AREA
+                    'Line': 'line',
+                    'Column': 'column',
+                    'Area': 'area',
+                    'Scatter': 'scatter',
+                    'Pie': 'pie'
                 };
 
+                scope.stackingOptions = {
+                    "None": "none",
+                    "Normal": "normal",
+                    "Percent": "percent"
+                };
+
+                scope.stacking = "none";
+
                 if (!scope.vis) {
                     // create new visualization
                     // wait for query to load to populate with defaults
@@ -77,33 +87,57 @@
                                 'query_id': q.id,
                                 'type': Visualization.prototype.TYPES.CHART,
                                 'name': '',
-                                'description': q.description,
-                                'options': newOptions()
+                                'description': q.description || '',
+                                'options': newOptions(Visualization.prototype.TYPES.CHART)
                             };
                         }
                     }, true);
                 }
 
                 function newOptions(chartType) {
-                    if (chartType === Visualization.prototype.TYPES.COHORT) {
-                        // empty config at the moment
-                        return {};
-                    }
-
-                    // Chart
-                    return {
-                        'series': {
-                            'type': Visualization.prototype.SERIES_TYPES.LINE
-                        }
+                    if (chartType === Visualization.prototype.TYPES.CHART) {
+                        return {
+                            'series': {
+                                'type': 'column',
+                                'stacking': null
+                            }
+                        };
                     };
+
+                    return {};
                 }
 
+                var chartOptionsUnwatch = null;
+
                 scope.$watch('vis.type', function(type) {
                     // if not edited by user, set name to match type
                     if (type && scope.vis && !scope.visForm.name.$dirty) {
                         // poor man's titlecase
                         scope.vis.name = scope.vis.type[0] + scope.vis.type.slice(1).toLowerCase();
                     }
+
+                    if (type && type == Visualization.prototype.TYPES.CHART) {
+                        if (scope.vis.options.series.stacking === null) {
+                            scope.stacking = "none";
+                        } else if (scope.vis.options.series.stacking === undefined) {
+                            scope.stacking = "normal";
+                        } else {
+                            scope.stacking = scope.vis.options.series.stacking ;
+                        }
+
+                        chartOptionsUnwatch = scope.$watch("stacking", function(stacking) {
+                            if (stacking == "none") {
+                                scope.vis.options.series.stacking = null;
+                            } else {
+                                scope.vis.options.series.stacking = stacking;
+                            }
+                        });
+                    } else {
+                        if (chartOptionsUnwatch) {
+                            chartOptionsUnwatch();
+                            chartOptionsUnwatch = null;
+                        }
+                    }
                 });
 
                 scope.toggleAdvancedMode = function() {
@@ -111,7 +145,7 @@
                 };
 
                 scope.typeChanged = function() {
-                    scope.vis.options = newOptions();
+                    scope.vis.options = newOptions(scope.vis.type);
                 };
 
                 scope.submit = function() {

rd_ui/app/scripts/ng-highchart.js

@@ -1,37 +1,10 @@
-(function(){
+(function () {
     'use strict';
 
     var defaultOptions = {
         title: {
             "text": null
         },
-        tooltip: {
-            valueDecimals: 2,
-            formatter: function () {
-                if (moment.isMoment(this.x)) {
-                    var s = '<b>' + moment(this.x).format("DD/MM/YY HH:mm") + '</b>',
-                        pointsCount = this.points.length;
-
-                    $.each(this.points, function (i, point) {
-                        s += '<br/><span style="color:'+point.series.color+'">' + point.series.name + '</span>: ' +
-                            Highcharts.numberFormat(point.y);
-
-                        if (pointsCount > 1 && point.percentage) {
-                            s += " (" + Highcharts.numberFormat(point.percentage) + "%)";
-                        }
-                    });
-                } else {
-                    var s = "<b>" + this.points[0].key + "</b>";
-                    $.each(this.points, function (i, point) {
-                        s+= '<br/><span style="color:'+point.series.color+'">' + point.series.name + '</span>: ' +
-                            Highcharts.numberFormat(point.y);
-                    });
-                }
-
-                return s;
-            },
-            shared: true
-        },
         xAxis: {
             type: 'datetime'
         },
@@ -40,6 +13,47 @@
                 text: null
             }
         },
+        tooltip: {
+            valueDecimals: 2,
+            formatter: function () {
+                if (!this.points) {
+                    this.points = [this.point];
+                };
+
+                if (moment.isMoment(this.x)) {
+                    var s = '<b>' + moment(this.x).format("DD/MM/YY HH:mm") + '</b>',
+                        pointsCount = this.points.length;
+
+                    $.each(this.points, function (i, point) {
+                        s += '<br/><span style="color:' + point.series.color + '">' + point.series.name + '</span>: ' +
+                            Highcharts.numberFormat(point.y);
+
+                        if (pointsCount > 1 && point.percentage) {
+                            s += " (" + Highcharts.numberFormat(point.percentage) + "%)";
+                        }
+                    });
+                } else {
+                    var points = this.points;
+                    var name = points[0].key || points[0].name;
+
+                    var s = "<b>" + name + "</b>";
+
+                    $.each(points, function (i, point) {
+                        if (points.length > 1) {
+                            s += '<br/><span style="color:' + point.series.color + '">' + point.series.name + '</span>: ' + Highcharts.numberFormat(point.y);
+                        } else {
+                            s += ": " + Highcharts.numberFormat(point.y);
+                            if (point.percentage < 100) {
+                                s += ' (' +Highcharts.numberFormat(point.percentage) +  '%)';
+                            }
+                        }
+                    });
+                }
+
+                return s;
+            },
+            shared: true
+        },
         exporting: {
             chartOptions: {
                 title: {
@@ -70,12 +84,63 @@
             enabled: false
         },
         plotOptions: {
-            "column": {
-                "stacking": "normal",
-                "pointPadding": 0,
-                "borderWidth": 1,
-                "groupPadding": 0,
-                "shadow": false
+            area: {
+                marker: {
+                    enabled: false,
+                    symbol: 'circle',
+                    radius: 2,
+                    states: {
+                        hover: {
+                            enabled: true
+                        }
+                    }
+                }
+            },
+            column: {
+                stacking: "normal",
+                pointPadding: 0,
+                borderWidth: 1,
+                groupPadding: 0,
+                shadow: false
+            },
+            line: {
+                marker: {
+                    radius: 1
+                },
+                lineWidth: 2,
+                states: {
+                    hover: {
+                        lineWidth: 2,
+                        marker: {
+                            radius: 3
+                        }
+                    }
+                }
+            },
+            pie: {
+                allowPointSelect: true,
+                cursor: 'pointer',
+                dataLabels: {
+                    enabled: true,
+                    color: '#000000',
+                    connectorColor: '#000000',
+                    format: '<b>{point.name}</b>: {point.percentage:.1f} %'
+                }
+            },
+            scatter: {
+                marker: {
+                    radius: 5,
+                    states: {
+                        hover: {
+                            enabled: true,
+                            lineColor: 'rgb(100,100,100)'
+                        }
+                    }
+                },
+                tooltip: {
+                    headerFormat: '<b>{series.name}</b><br>',
+                    pointFormat: '{point.x}, {point.y}'
+                }
             }
         },
         series: []
@@ -105,26 +170,34 @@
 
                     var chartOptions = $.extend(true, {}, defaultOptions, chartsDefaults);
 
-                    // Update when options change
-                    scope.$watch('options', function(newOptions) {
-                        initChart(newOptions);
-                    }, true);
+                    // $timeout makes sure that this function invoked after the DOM ready. When draw/init
+                    // invoked after the DOM is ready, we see first an empty HighCharts objects and later
+                    // they get filled up. Which gives the feeling that the charts loading faster (otherwise
+                    // we stare at an empty screen until the HighCharts object is ready).
+                    $timeout(function(){
+                        // Update when options change
+                        scope.$watch('options', function (newOptions) {
+                            initChart(newOptions);
+                        }, true);
 
-                    //Update when charts data changes
-                    scope.$watch(function () {
-                        return (scope.series && scope.series.length) || 0;
-                    }, function (length) {
-                        if (!length || length == 0) {
-                            scope.chart.showLoading();
-                        } else {
-                            drawChart();
-                        };
-                    }, true);
+                        //Update when charts data changes
+                        scope.$watch(function () {
+                            // TODO: this might be an issue in case the series change, but they stay
+                            // with the same length
+                            return (scope.series && scope.series.length) || 0;
+                        }, function (length) {
+                            if (!length || length == 0) {
+                                scope.chart.showLoading();
+                            } else {
+                                drawChart();
+                            };
+                        }, true);
+                    });
 
                     function initChart(options) {
                         if (scope.chart) {
-                           scope.chart.destroy();
-                        }
+                            scope.chart.destroy();
+                        };
 
                         $.extend(true, chartOptions, options);
 
@@ -133,23 +206,25 @@
                     }
 
                     function drawChart() {
-                        while(scope.chart.series.length > 0) {
-                            scope.chart.series[0].remove(true);
-                        }
+                        while (scope.chart.series.length > 0) {
+                            scope.chart.series[0].remove(false);
+                        };
 
-                        // todo series.type
-
-                        if (_.some(scope.series[0].data, function(p) { return angular.isString(p.x) })) {
+                        if (_.some(scope.series[0].data, function (p) {
+                            return angular.isString(p.x)
+                        })) {
                             scope.chart.xAxis[0].update({type: 'category'});
 
                             // We need to make sure that for each category, each series has a value.
-                            var categories = _.union.apply(this, _.map(scope.series, function(s) { return _.pluck(s.data,'x')}));
+                            var categories = _.union.apply(this, _.map(scope.series, function (s) {
+                                return _.pluck(s.data, 'x')
+                            }));
 
-                            _.each(scope.series, function(s) {
+                            _.each(scope.series, function (s) {
                                 // TODO: move this logic to Query#getChartData
                                 var yValues = _.groupBy(s.data, 'x');
 
-                                var newData = _.sortBy(_.map(categories, function(category) {
+                                var newData = _.sortBy(_.map(categories, function (category) {
                                     return {
                                         name: category,
                                         y: yValues[category] && yValues[category][0].y
@@ -164,11 +239,27 @@
 
                         scope.chart.counters.color = 0;
 
-                        _.each(scope.series, function(s) {
+                        _.each(scope.series, function (s) {
                             // here we override the series with the visualization config
-                            var _s = $.extend(true, {}, s, chartOptions['series']);
-                            scope.chart.addSeries(_s);
-                        })
+                            s = _.extend(s, chartOptions['series']);
+
+                            if (s.type == 'area') {
+                                _.each(s.data, function (p) {
+                                    // This is an insane hack: somewhere deep in HighChart's code,
+                                    // when you stack areas, it tries to convert the string representation
+                                    // of point's x into a number. With the default implementation of toString
+                                    // it fails....
+
+                                    if (moment.isMoment(p.x)) {
+                                        p.x.toString = function () {
+                                            return String(this.toDate().getTime());
+                                        };
+                                    }
+                                });
+                            };
+
+                            scope.chart.addSeries(s, false);
+                        });
 
                         scope.chart.redraw();
                         scope.chart.hideLoading();

rd_ui/app/scripts/services.js

@@ -291,11 +291,6 @@
                 'CHART': 'CHART',
                 'COHORT': 'COHORT',
                 'TABLE': 'TABLE'
-            },
-            SERIES_TYPES: {
-                'LINE': 'line',
-                'BAR': 'bar',
-                'AREA': 'area'
             }
         };
 

rd_ui/app/views/dashboard.html

@@ -21,7 +21,7 @@
 
             <div class="panel panel-default">
                 <div class="panel-heading">
-                    <h3 class="panel-title" style="cursor: pointer;" ng-click="open(query)">
+                    <h3 class="panel-title" style="cursor: pointer;" ng-click="open(query, widget.visualization)">
                         <p>
                             <span ng-bind="query.name"></span>
                         </p>
@@ -37,7 +37,7 @@
                           tooltip-placement="bottom">Updated: <span am-time-ago="queryResult.getUpdatedAt()"></span></span>
 
                     <span class="pull-right">
-                        <a class="btn btn-default btn-xs" ng-href="/queries/{{query.id}}"><span class="glyphicon glyphicon-link"></span></a>
+                        <a class="btn btn-default btn-xs" ng-href="/queries/{{query.id}}#{{widget.visualization.id}}"><span class="glyphicon glyphicon-link"></span></a>
                         <button type="button" class="btn btn-default btn-xs" ng-show="dashboard.canEdit()" ng-click="deleteWidget()" title="Remove Widget"><span class="glyphicon glyphicon-trash"></span></button>
                     </span>
 

rd_ui/app/views/edit_visualization.html

@@ -12,6 +12,9 @@
   <div class="form-group" ng-show="vis.type == visTypes.Chart">
     <label class="control-label">Chart Type</label>
     <select required ng-model="vis.options.series.type" ng-options="value as key for (key, value) in seriesTypes" class="form-control"></select>
+
+    <label class="control-label">Stacking</label>
+    <select required ng-model="stacking" ng-options="value as key for (key, value) in stackingOptions" class="form-control"></select>
   </div>
 
   <div class="form-group">

rd_ui/app/views/queryfiddle.html

@@ -56,9 +56,9 @@
             <rd-tab id="pivot" name="Pivot Table"></rd-tab>
             <!-- hide the table visualization -->
             <rd-tab id="{{vis.id}}" name="{{vis.name}}" ng-hide="vis.type=='TABLE'" ng-repeat="vis in query.visualizations">
-                <span class="remove" ng-click="deleteVisualization($event, vis)"> &times;</span>
+                <span class="remove" ng-click="deleteVisualization($event, vis)" ng-show="currentUser.canEdit(query)"> &times;</span>
             </rd-tab>
-            <rd-tab id="add" name="&plus;New" removeable="true"></rd-tab>
+            <rd-tab id="add" name="&plus;New" removeable="true" ng-show="currentUser.canEdit(query)"></rd-tab>
         </ul>
 
         <div class="col-lg-12" ng-show="selectedTab == 'table'">
@@ -70,12 +70,16 @@
         </div>
 
         <div class="col-lg-12" ng-show="selectedTab == vis.id" ng-repeat="vis in query.visualizations">
-            <div class="row">
+            <div class="row" ng-show="currentUser.canEdit(query)">
                 <p>
-                    <div class="col-lg-6">
+                    <div class="col-lg-12">
                         <edit-visulatization-form vis="vis" query="query"></edit-visulatization-form>
                     </div>
-                    <div class="col-lg-6">
+                </p>
+            </div>
+            <div class="row">
+                <p>
+                    <div class="col-lg-12">
                         <visualization-renderer visualization="vis" query-result="queryResult"></visualization-renderer>
                     </div>
                 </p>

redash/__init__.py

@@ -7,7 +7,7 @@ from flask_peewee.db import Database
 import redis
 from redash import settings, utils
 
-__version__ = '0.3.1'
+__version__ = '0.3.2'
 
 app = Flask(__name__,
             template_folder=settings.STATIC_ASSETS_PATH,

redash/controllers.py

@@ -204,12 +204,11 @@ class QueryAPI(BaseResource):
         if 'latest_query_data_id' in query_def:
             query_def['latest_query_data'] = query_def.pop('latest_query_data_id')
 
-        update = models.Query.update(**query_def).where(models.Query.id == query_id)
-        update.execute()
-
+        models.Query.update_instance(query_id, **query_def)
+        
         query = models.Query.get_by_id(query_id)
 
-        return query.to_dict(with_result=False)
+        return query.to_dict(with_result=False, with_visualizations=True)
 
     def get(self, query_id):
         q = models.Query.get(models.Query.id == query_id)

redash/data/manager.py

@@ -153,9 +153,12 @@ class Manager(object):
         if self.workers:
             return self.workers
         
-        if getattr(settings, 'CONNECTION_ADAPTER', None) == "mysql":
+        if connection_type == 'mysql':
             from redash.data import query_runner_mysql
             runner = query_runner_mysql.mysql(connection_string)
+        elif connection_type == 'graphite':
+            from redash.data import query_runner_graphite
+            runner = query_runner_graphite.graphite(connection_string)
         else:
             from redash.data import query_runner
             runner = query_runner.redshift(connection_string)

redash/data/query_runner_graphite.py

@@ -0,0 +1,46 @@
+"""
+QueryRunner for Graphite.
+"""
+import json
+import datetime
+import requests
+from redash.utils import JSONEncoder
+
+
+def graphite(connection_params):
+    def transform_result(response):
+        columns = [{'name': 'Time::x'}, {'name': 'value::y'}, {'name': 'name::series'}]
+        rows = []
+
+        for series in response.json():
+            for values in series['datapoints']:
+                timestamp = datetime.datetime.fromtimestamp(int(values[1]))
+                rows.append({'Time::x': timestamp, 'name::series': series['target'], 'value::y': values[0]})
+
+        data = {'columns': columns, 'rows': rows}
+        return json.dumps(data, cls=JSONEncoder)
+
+    def query_runner(query):
+        base_url = "%s/render?format=json&" % connection_params['url']
+        url = "%s%s" % (base_url, "&".join(query.split("\n")))
+        error = None
+        data = None
+
+        try:
+            response = requests.get(url, auth=connection_params['auth'],
+                                    verify=connection_params['verify'])
+
+            if response.status_code == 200:
+                data = transform_result(response)
+            else:
+                error = "Failed getting results (%d)" % response.status_code
+
+        except Exception, ex:
+            data = None
+            error = ex.message
+
+        return data, error
+
+    query_runner.annotate_query = False
+
+    return query_runner

redash/data/worker.py

@@ -234,8 +234,11 @@ class Worker(threading.Thread):
         start_time = time.time()
         self.set_title("running query %s" % job_id)
 
-        annotated_query = "/* Pid: %s, Job Id: %s, Query hash: %s, Priority: %s */ %s" % \
-                          (pid, job.id, job.query_hash, job.priority, job.query)
+        if getattr(self.query_runner, 'annotate_query', True):
+            annotated_query = "/* Pid: %s, Job Id: %s, Query hash: %s, Priority: %s */ %s" % \
+                              (pid, job.id, job.query_hash, job.priority, job.query)
+        else:
+            annotated_query = job.query
 
         # TODO: here's the part that needs to be forked, not all of the worker process...
         data, error = self.query_runner(annotated_query)

redash/models.py

@@ -64,7 +64,7 @@ class Query(BaseModel):
 
     def create_default_visualizations(self):
         table_visualization = Visualization(query=self, name="Table",
-                                            description=self.description,
+                                            description='',
                                             type="TABLE", options="{}")
         table_visualization.save()
 
@@ -115,6 +115,14 @@ LEFT OUTER JOIN
         """
         return cls.raw(query)
 
+    @classmethod
+    def update_instance(cls, query_id, **kwargs):
+        if 'query' in kwargs:
+            kwargs['query_hash'] = utils.gen_query_hash(kwargs['query'])
+
+        update = cls.update(**kwargs).where(cls.id == query_id)
+        return update.execute()
+
     def save(self, *args, **kwargs):
         self.query_hash = utils.gen_query_hash(self.query)
         self._set_api_key()
@@ -185,7 +193,7 @@ class Visualization(BaseModel):
     type = peewee.CharField(max_length=100)
     query = peewee.ForeignKeyField(Query, related_name='visualizations')
     name = peewee.CharField(max_length=255)
-    description = peewee.CharField(max_length=4096)
+    description = peewee.CharField(max_length=4096, null=True)
     options = peewee.TextField()
 
     class Meta:

redash/settings.py

@@ -0,0 +1,49 @@
+import os
+import urlparse
+
+
+def parse_db_url(url):
+    url_parts = urlparse.urlparse(url)
+    connection = {
+        'engine': 'peewee.PostgresqlDatabase',
+    }
+
+    if url_parts.hostname and not url_parts.path:
+        connection['name'] = url_parts.hostname
+    else:
+        connection['name'] = url_parts.path[1:]
+        connection['host'] = url_parts.hostname
+        connection['port'] = url_parts.port
+        connection['user'] = url_parts.username
+        connection['password'] = url_parts.password
+
+    return connection
+
+
+def fix_assets_path(path):
+    fullpath = os.path.join(os.path.dirname(__file__), path)
+    return fullpath
+
+REDIS_URL = os.environ.get('REDASH_REDIS_URL', "redis://localhost:6379")
+
+# "pg", "graphite" or "mysql"
+CONNECTION_ADAPTER = os.environ.get("REDASH_CONNECTION_ADAPTER", "pg")
+# Connection string for the database that is used to run queries against. Examples:
+# -- mysql:    CONNECTION_STRING = "Server=;User=;Pwd=;Database="
+# -- pg:       CONNECTION_STRING = "user= password= host= port=5439 dbname="
+# -- graphite: CONNECTION_STRING = {'url': 'https://graphite.yourcompany.com', 'auth': ('user', 'password'), 'verify': True}
+CONNECTION_STRING = os.environ.get("REDASH_CONNECTION_STRING", "user= password= host= port=5439 dbname=")
+
+# Connection settings for re:dash's own database (where we store the queries, results, etc)
+DATABASE_CONFIG = parse_db_url(os.environ.get("REDASH_DATABASE_URL", "postgresql://postgres"))
+
+# Google Apps domain to allow access from; any user with email in this Google Apps will be allowed
+# access
+GOOGLE_APPS_DOMAIN = os.environ.get("REDASH_GOOGLE_APPS_DOMAIN", "")
+# Email addresses of admin users (comma separated)
+ADMINS = os.environ.get("REDASH_ADMINS", '').split(',')
+STATIC_ASSETS_PATH = fix_assets_path(os.environ.get("REDASH_STATIC_ASSETS_PATH", "../rd_ui/dist/"))
+WORKERS_COUNT = int(os.environ.get("REDASH_WORKERS_COUNT", "2"))
+COOKIE_SECRET = os.environ.get("REDASH_COOKIE_SECRET", "c292a0a3aa32397cdb050e233733900f")
+LOG_LEVEL = os.environ.get("REDASH_LOG_LEVEL", "INFO")
+ANALYTICS = os.environ.get("REDASH_ANALYTICS", "")

redash/settings_example.py

@@ -1,29 +0,0 @@
-"""
-Example settings module. You should make your own copy as settings.py and enter the real settings.
-"""
-REDIS_URL = "redis://localhost:6379"
-
-# Either "pg" or "mysql"
-CONNECTION_ADAPTER = "pg"
-# Connection string for the database that is used to run queries against
-# -- example mysql CONNECTION_STRING = "Server=;User=;Pwd=;Database="
-# -- example pg    CONNECTION_STRING = "user= password= host= port=5439 dbname="
-CONNECTION_STRING = "user= password= host= port=5439 dbname="
-# Connection settings for re:dash's own database (where we store the queries, results, etc)
-DATABASE_CONFIG = {
-    'name': 'postgres',
-    'engine': 'peewee.PostgresqlDatabase',
-}
-# Google Apps domain to allow access from; any user with email in this Google Apps will be allowed
-# access
-GOOGLE_APPS_DOMAIN = ""
-# Email addresses of specific users not from the above set Google Apps Domain, that you want to
-# allow access to re:dash
-ALLOWED_USERS = []
-# Email addresses of admin users
-ADMINS = []
-STATIC_ASSETS_PATH = "../rd_ui/dist/"
-WORKERS_COUNT = 2
-COOKIE_SECRET = "c292a0a3aa32397cdb050e233733900f"
-LOG_LEVEL = "INFO"
-ANALYTICS = ""

requirements.txt

@@ -23,3 +23,4 @@ sqlparse==0.1.8
 wsgiref==0.1.2
 wtf-peewee==0.2.2
 Flask-Script==0.6.6
+honcho==0.5.0

tests/models.py

@@ -1,15 +0,0 @@
-from tests import BaseTestCase
-from factories import dashboard_factory
-
-
-class DashboardTest(BaseTestCase):
-    def test_appends_suffix_to_slug_when_duplicate(self):
-        d1 = dashboard_factory.create()
-        self.assertEquals(d1.slug, 'test')
-
-        d2 = dashboard_factory.create()
-        self.assertNotEquals(d1.slug, d2.slug)
-
-        d3 = dashboard_factory.create()
-        self.assertNotEquals(d1.slug, d3.slug)
-        self.assertNotEquals(d2.slug, d3.slug)

tests/test_models.py

@@ -0,0 +1,28 @@
+from tests import BaseTestCase
+from redash import models
+from factories import dashboard_factory, query_factory
+
+
+class DashboardTest(BaseTestCase):
+    def test_appends_suffix_to_slug_when_duplicate(self):
+        d1 = dashboard_factory.create()
+        self.assertEquals(d1.slug, 'test')
+
+        d2 = dashboard_factory.create()
+        self.assertNotEquals(d1.slug, d2.slug)
+
+        d3 = dashboard_factory.create()
+        self.assertNotEquals(d1.slug, d3.slug)
+        self.assertNotEquals(d2.slug, d3.slug)
+
+
+class QueryTest(BaseTestCase):
+    def test_changing_query_text_changes_hash(self):
+        q = query_factory.create()
+
+        old_hash = q.query_hash
+        models.Query.update_instance(q.id, query="SELECT 2;")
+
+        q = models.Query.get_by_id(q.id)
+
+        self.assertNotEquals(old_hash, q.query_hash)

tests/test_settings.py

@@ -0,0 +1,27 @@
+from redash import settings as settings
+from unittest import TestCase
+
+
+class TestDatabaseUrlParser(TestCase):
+    def test_only_database_name(self):
+        config = settings.parse_db_url("postgresql://postgres")
+        self.assertEquals(config['name'], 'postgres')
+
+    def test_host_and_database_name(self):
+        config = settings.parse_db_url("postgresql://localhost/postgres")
+        self.assertEquals(config['name'], 'postgres')
+        self.assertEquals(config['host'], 'localhost')
+
+    def test_host_with_port_and_database_name(self):
+        config = settings.parse_db_url("postgresql://localhost:5432/postgres")
+        self.assertEquals(config['name'], 'postgres')
+        self.assertEquals(config['host'], 'localhost')
+        self.assertEquals(config['port'], 5432)
+
+    def test_full_url(self):
+        config = settings.parse_db_url("postgresql://user:pass@localhost:5432/postgres")
+        self.assertEquals(config['name'], 'postgres')
+        self.assertEquals(config['host'], 'localhost')
+        self.assertEquals(config['port'], 5432)
+        self.assertEquals(config['user'], 'user')
+        self.assertEquals(config['password'], 'pass')