rrd-grapher 1.0.0

data/spec/javascripts/helpers/jasmine-jquery-1.3.0.js

@@ -0,0 +1,283 @@
+var readFixtures = function() {
+  return jasmine.getFixtures().proxyCallTo_('read', arguments);
+};
+
+var preloadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('preload', arguments);
+};
+
+var loadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('load', arguments);
+};
+
+var setFixtures = function(html) {
+  jasmine.getFixtures().set(html);
+};
+
+var sandbox = function(attributes) {
+  return jasmine.getFixtures().sandbox(attributes);
+};
+
+var spyOnEvent = function(selector, eventName) {
+  jasmine.JQuery.events.spyOn(selector, eventName);
+}
+
+jasmine.getFixtures = function() {
+  return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures();
+};
+
+jasmine.Fixtures = function() {
+  this.containerId = 'jasmine-fixtures';
+  this.fixturesCache_ = {};
+  this.fixturesPath = 'spec/javascripts/fixtures';
+};
+
+jasmine.Fixtures.prototype.set = function(html) {
+  this.cleanUp();
+  this.createContainer_(html);
+};
+
+jasmine.Fixtures.prototype.preload = function() {
+  this.read.apply(this, arguments);
+};
+
+jasmine.Fixtures.prototype.load = function() {
+  this.cleanUp();
+  this.createContainer_(this.read.apply(this, arguments));
+};
+
+jasmine.Fixtures.prototype.read = function() {
+  var htmlChunks = [];
+
+  var fixtureUrls = arguments;
+  for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
+    htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]));
+  }
+
+  return htmlChunks.join('');
+};
+
+jasmine.Fixtures.prototype.clearCache = function() {
+  this.fixturesCache_ = {};
+};
+
+jasmine.Fixtures.prototype.cleanUp = function() {
+  jQuery('#' + this.containerId).remove();
+};
+
+jasmine.Fixtures.prototype.sandbox = function(attributes) {
+  var attributesToSet = attributes || {};
+  return jQuery('<div id="sandbox" />').attr(attributesToSet);
+};
+
+jasmine.Fixtures.prototype.createContainer_ = function(html) {
+  var container = jQuery('<div id="' + this.containerId + '" />');
+  container.html(html);
+  jQuery('body').append(container);
+};
+
+jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {  
+  if (typeof this.fixturesCache_[url] == 'undefined') {
+    this.loadFixtureIntoCache_(url);
+  }
+  return this.fixturesCache_[url];
+};
+
+jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
+  var self = this;
+  var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl;
+  jQuery.ajax({
+    async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
+    cache: false,
+    dataType: 'html',
+    url: url,
+    success: function(data) {
+      self.fixturesCache_[relativeUrl] = data;
+    },
+    error: function(jqXHR, status, errorThrown) {
+        throw Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')');
+    }
+  });
+};
+
+jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
+  return this[methodName].apply(this, passedArguments);
+};
+
+
+jasmine.JQuery = function() {};
+
+jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
+  return jQuery('<div/>').append(html).html();
+};
+
+jasmine.JQuery.elementToString = function(element) {
+  return jQuery('<div />').append(element.clone()).html();
+};
+
+jasmine.JQuery.matchersClass = {};
+
+(function(namespace) {
+  var data = {
+    spiedEvents: {},
+    handlers:    []
+  };
+
+  namespace.events = {
+    spyOn: function(selector, eventName) {
+      var handler = function(e) {
+        data.spiedEvents[[selector, eventName]] = e;
+      };
+      jQuery(selector).bind(eventName, handler);
+      data.handlers.push(handler);
+    },
+
+    wasTriggered: function(selector, eventName) {
+      return !!(data.spiedEvents[[selector, eventName]]);
+    },
+
+    cleanUp: function() {
+      data.spiedEvents = {};
+      data.handlers    = [];
+    }
+  }
+})(jasmine.JQuery);
+
+(function(){
+  var jQueryMatchers = {
+    toHaveClass: function(className) {
+      return this.actual.hasClass(className);
+    },
+
+    toBeVisible: function() {
+      return this.actual.is(':visible');
+    },
+
+    toBeHidden: function() {
+      return this.actual.is(':hidden');
+    },
+
+    toBeSelected: function() {
+      return this.actual.is(':selected');
+    },
+
+    toBeChecked: function() {
+      return this.actual.is(':checked');
+    },
+
+    toBeEmpty: function() {
+      return this.actual.is(':empty');
+    },
+
+    toExist: function() {
+      return this.actual.size() > 0;
+    },
+
+    toHaveAttr: function(attributeName, expectedAttributeValue) {
+      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
+    },
+
+    toHaveId: function(id) {
+      return this.actual.attr('id') == id;
+    },
+
+    toHaveHtml: function(html) {
+      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
+    },
+
+    toHaveText: function(text) {
+      if (text && jQuery.isFunction(text.test)) {
+        return text.test(this.actual.text());
+      } else {
+        return this.actual.text() == text;
+      }
+    },
+
+    toHaveValue: function(value) {
+      return this.actual.val() == value;
+    },
+
+    toHaveData: function(key, expectedValue) {
+      return hasProperty(this.actual.data(key), expectedValue);
+    },
+
+    toBe: function(selector) {
+      return this.actual.is(selector);
+    },
+
+    toContain: function(selector) {
+      return this.actual.find(selector).size() > 0;
+    },
+
+    toBeDisabled: function(selector){
+      return this.actual.is(':disabled');
+    },
+
+    // tests the existence of a specific event binding
+    toHandle: function(eventName) {
+      var events = this.actual.data("events");
+      return events && events[eventName].length > 0;
+    },
+    
+    // tests the existence of a specific event binding + handler
+    toHandleWith: function(eventName, eventHandler) {
+      var stack = this.actual.data("events")[eventName];
+      var i;
+      for (i = 0; i < stack.length; i++) {
+        if (stack[i].handler == eventHandler) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+
+  var hasProperty = function(actualValue, expectedValue) {
+    if (expectedValue === undefined) {
+      return actualValue !== undefined;
+    }
+    return actualValue == expectedValue;
+  };
+
+  var bindMatcher = function(methodName) {
+    var builtInMatcher = jasmine.Matchers.prototype[methodName];
+
+    jasmine.JQuery.matchersClass[methodName] = function() {
+      if (this.actual instanceof jQuery) {
+        var result = jQueryMatchers[methodName].apply(this, arguments);
+        this.actual = jasmine.JQuery.elementToString(this.actual);
+        return result;
+      }
+
+      if (builtInMatcher) {
+        return builtInMatcher.apply(this, arguments);
+      }
+
+      return false;
+    };
+  };
+
+  for(var methodName in jQueryMatchers) {
+    bindMatcher(methodName);
+  }
+})();
+
+beforeEach(function() {
+  this.addMatchers(jasmine.JQuery.matchersClass);
+  this.addMatchers({
+    toHaveBeenTriggeredOn: function(selector) {
+      this.message = function() {
+        return [
+          "Expected event " + this.actual + " to have been triggered on" + selector,
+          "Expected event " + this.actual + " not to have been triggered on" + selector
+        ];
+      };
+      return jasmine.JQuery.events.wasTriggered(selector, this.actual);
+    }
+  })
+});
+
+afterEach(function() {
+  jasmine.getFixtures().cleanUp();
+  jasmine.JQuery.events.cleanUp();
+});

data/spec/javascripts/source/format_spec.coffee

@@ -0,0 +1,18 @@
+
+describe "Format", ->
+  beforeEach ->
+    @f = Format
+  
+  it "can format speed", ->
+    expect( @f.speed(2048) ).toEqual("2.00 KB/s")
+    expect( @f.speed(2097152) ).toEqual("2.00 MB/s")
+  
+  it "can format size", ->
+    expect( @f.size(2048) ).toEqual("2.00 KB")
+    expect( @f.size(2097152) ).toEqual("2.00 MB")
+  
+  it "can format time duration", ->
+    expect( @f.delay(100) ).toEqual("100.00 ms")
+    expect( @f.delay(1000 * 2) ).toEqual("2.00 s")
+    expect( @f.delay(1000 * 60 * 2) ).toEqual("2.00 m")
+    expect( @f.delay(1000 * 60 * 60 * 2) ).toEqual("2.00 h")

data/spec/javascripts/source/graph_def_spec.coffee

@@ -0,0 +1,27 @@
+
+describe "NetworkGraph", ->
+  beforeEach ->
+    container = $('<div>')
+    @def = new NetworkGraph(container, "test.com", "en0")
+  
+  it "should initialize correctly", ->
+    series = @def.graph.get("series")
+    expect(series.length).toEqual(2)
+    expect(series[0].rrd_path).toEqual("test.com/interface/if_octets-en0")
+    expect(series[1].rrd_path).toEqual("test.com/interface/if_octets-en0")
+
+describe "GraphPage", ->
+  beforeEach ->
+    @container = $('<div>')
+    @page = new GraphPage(@container, "test.com")
+  
+  it "can be created", ->
+    expect(@page.graphs).toEqual([])
+  
+  it "can include graph definitions", ->
+    @page.addGraph("NetworkGraph", "en0")
+    expect(@page.graphs.length).toEqual(1)
+    expect(@page.graphs[0]).toEqual(jasmine.any(Object))
+    # check object "class", the should be a more straight forward way to do this...
+    expect(@page.graphs[0].constructor.prototype).toBe( (new NetworkGraph("a1")).constructor.prototype )
+  

data/spec/javascripts/source/graph_spec.coffee

@@ -0,0 +1,63 @@
+
+describe "Graph", ->
+  beforeEach ->
+    @container = $("<div>")
+    @graph = new Graph("Graph Title", @container, null, null)
+  
+  it "should create required children", ->
+    expect(@container).toContain("div.graph_title")
+    expect(@container).toContain("div.graph_container")
+    expect(@container).toContain("div.legend")
+    expect(@container).toContain("div.graph")
+  
+  it "should allow adding serie", ->
+    expect(@graph.get("series").length).toEqual(0)
+    create_spy = spyOn(window, "Serie")
+    @graph.addSerie("path/to/file.rrd", "my_ds", "legend_text", 1, null)
+    expect(@graph.get("series").length).toEqual(1)
+    # expect(create_spy).toHaveBeenCalledWith(["path/to/file.rrd", "my_ds", "legend_text", 1w, jasmine.any(Function)])
+  
+  it "should allow addingd static lines", ->
+    expect(@graph.get("lines").length).toEqual(0)
+    @graph.addLine(13, "red")
+    expect(@graph.get("lines").length).toEqual(1)
+  
+  it "should update its view when created", ->
+    update_spy = spyOn(@graph, "update_graph")
+    @graph.create()
+    expect(update_spy).toHaveBeenCalledWith(true)
+    
+  it "should fetch new data when updating", ->
+    ajax_spies = spyOn(@graph, "multiple_get")
+    @graph.addSerie("path/to/file.rrd", "my_ds", "legend_text", 0, null)
+    @graph.update_graph(true)
+    expect(ajax_spies)
+    
+    expect(ajax_spies.mostRecentCall.args.length).toEqual(2)
+    expect(ajax_spies.mostRecentCall.args[0][0]).toEqual([jasmine.any(String), jasmine.any(Object)])
+    # expect(ajax_spies.argsForCall[0][0][0]).toMatch("^\/rrd\/$")
+  
+  it "should be able to fetch new data", ->
+    ajax_request = spyOn($, "getJSON")
+    
+    cb = jasmine.createSpy()
+    
+    s = new Object
+    s.set_data = jasmine.createSpy()
+    s.get_definition = jasmine.createSpy().andReturn("none")
+    # serie_set_data = spyOn(s, "set_data")
+    
+    @graph.multiple_get([["/url1", s]], cb)
+    
+    expect(ajax_request).toHaveBeenCalledWith("/url1", jasmine.any(Function))
+    ajax_request.mostRecentCall.args[1]([[0, 1], [1, 42]])
+    expect(s.set_data).toHaveBeenCalledWith([[0, 1], [1, 42]])
+    
+    expect(cb).toHaveBeenCalledWith(["none"])
+  
+  # it "should be able to play a Song", ->
+  #   @player.play(@song)
+  #   expect(@player.currentlyPlayingSong).toEqual(@song)
+  # 
+  #   # demonstrates use of custom matcher
+  #   expect(@player).toBePlaying(@song)

data/spec/javascripts/source/serie_spec.coffee

@@ -0,0 +1,28 @@
+
+describe "Serie", ->
+  beforeEach ->
+    @serie = new Serie("/rrd/path", "ds_name", "Serie Name")
+  
+  it "should be enabled by default", ->
+    expect(@serie.enabled).toEqual(true)
+  
+  it "should return its definition", ->
+    expected_def = {
+        data: [],
+        label: "Serie Name",
+        yaxis: 1,
+        color: 'black'
+      }
+    expect(@serie.get_definition()).toEqual(expected_def)
+  
+  it "should allow toggling its enable state", ->
+    @serie.toggle_enabled()
+    expect(@serie.enabled).toEqual(false)
+    @serie.toggle_enabled()
+    expect(@serie.enabled).toEqual(true)
+  
+  it "should allow directly setting its enable state", ->
+    @serie.set_enabled(false)
+    expect(@serie.enabled).toEqual(false)
+    @serie.set_enabled(true)
+    expect(@serie.enabled).toEqual(true)

data/spec/javascripts/source/static_line_spec.coffee

@@ -0,0 +1,13 @@
+
+describe "StaticLine", ->
+  beforeEach ->
+    @line = new StaticLine(13, "red")
+  
+  
+  it "should return its definition", ->
+    expected_def = {
+        data: [[jasmine.any(Number), 13], [jasmine.any(Number), 13]],
+        legend: "",
+        color: 'red'
+      }
+    expect(@line.get_definition(0, 1)).toEqual(expected_def)

data/spec/javascripts/source/time_spec.coffee

@@ -0,0 +1,26 @@
+
+describe "Time", ->
+  beforeEach ->
+    # fake a 10 seconds offset
+    Time.tz_offset = 10
+  
+  
+  it "can convert Time From UTC to local", ->
+    time = 100
+    utc_time = Time.utc_to_local(time)
+    expect(utc_time).toEqual( 110 )
+  
+  it "can convert Time From local to UTC", ->
+    time = 100
+    utc_time = Time.local_to_utc(time)
+    expect(utc_time).toEqual( 90 )
+  
+  it "can convert Client timestamp to Server timestamp", ->
+    client_time = 100 * 1000
+    server_time = Time.client_to_server(client_time)
+    expect(server_time).toEqual(90)
+
+  it "can convert Server timestamp to Client timestamp", ->
+    server_time = 90
+    client_time = Time.server_to_client(server_time)
+    expect(client_time).toEqual(100 * 1000)

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,78 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+    - lib/rrd-grapher/public/javascripts/jquery/jquery-1.6.2.js
+    - lib/rrd-grapher/public/javascripts/flot/jquery.flot.js
+    - lib/rrd-grapher/public/javascripts/backbone/underscore.js
+    - lib/rrd-grapher/public/javascripts/backbone/backbone.js
+    - lib/rrd-grapher/public/javascripts/app.js
+    - lib/rrd-grapher/public/javascripts/classes/**/*.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+
+# spec_files
+#
+#  Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir:
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir:

data/spec/javascripts/support/jasmine_config.rb

@@ -0,0 +1,23 @@
+module Jasmine
+  class Config
+
+    # Add your overrides or custom config code here
+
+  end
+end
+
+
+# Note - this is necessary for rspec2, which has removed the backtrace
+module Jasmine
+  class SpecBuilder
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      @spec_ids << spec["id"]
+      backtrace = @example_locations[parent.description + " " + example_name]
+      parent.it example_name, {} do
+        me.report_spec(spec["id"])
+      end
+    end
+  end
+end

data/spec/javascripts/support/jasmine_runner.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_config = Jasmine::Config.new
+spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+
+should_stop = false
+
+if Jasmine::rspec2?
+  RSpec.configuration.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+else
+  Spec::Runner.configure do |config|
+    config.after(:suite) do
+      spec_builder.stop if should_stop
+    end
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites