gregoryfoster-gchartrb 0.9

data/spec/gchartrb/fills_spec.rb

@@ -0,0 +1,124 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GoogleChart::Fills do
+  before(:each) do
+    @chart = GoogleChart::LineChart.new
+    @chart.data "Series 1", [1,2,3,4,5], "ff00ff"
+  end
+
+  it "is supported by LineChart, LineXYChart, BarChart, ScatterPlot and SparklineChart" do
+    [GoogleChart::LineChart, GoogleChart::LineXYChart,
+    GoogleChart::BarChart, GoogleChart::ScatterPlot, GoogleChart::SparklineChart].each do |klass|
+      klass.new.should respond_to(:fill)
+    end
+  end
+
+  it "throws ArgumentError if the the fill method is called with an invalid fill type" do
+    lambda { @chart.fill(:gibberish) }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an ArgumentError on accessing some property which does not exist" do
+    lambda { @chart.fill(:solid, :gibberish => "Yo") }.should raise_error(NoMethodError)
+    lambda do
+      @chart.fill :solid do |f|
+        f.gibberish = "Yo"
+      end
+    end.should raise_error(NoMethodError)
+  end
+
+  describe "Solid Fill" do
+    it "should be able to initialise the properties from within a block" do
+      @chart.fill :solid do |f|
+        f.type  = :background
+        f.color = "00ff00"
+      end
+      @chart.query_params[:chf].should be_eql("bg,s,00ff00")
+    end
+
+    it "should be able to initialise the properties via a hash" do
+      @chart.fill(:solid, :type => :background, :color => "00ff00")
+      @chart.query_params[:chf].should be_eql("bg,s,00ff00")
+    end
+
+    it "raises error on invalid type" do
+      lambda { @chart.fill(:solid, :type => :gibberish, :color => "00ff00") }.should raise_error(ArgumentError)
+    end
+
+    it "raises error on invalid colors" do
+      lambda { @chart.fill(:solid, :type => :background) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise ArgumentError if a non-background fill is not supported"
+
+  end
+
+  describe "Gradient Fill" do
+
+    before(:each) { @valid_gradient_values = {:type => :background, :angle => 45, :colors => ["ff00ff", "00ffff"], :offsets => [0,0.75]} }
+    it "should be able to initialise the properties from within a block" do
+      @chart.fill :gradient do |f|
+        f.type    = :background
+        f.angle   = 45
+        f.colors  = ["ff00ff", "00ffff"]
+        f.offsets = [0,0.75]
+      end
+      @chart.query_params[:chf].should be_eql("bg,lg,45,ff00ff,0,00ffff,0.75")
+    end
+
+    it "should be able to initialise the properties via a hash" do
+      @chart.fill(:gradient, @valid_gradient_values)
+      @chart.query_params[:chf].should be_eql("bg,lg,45,ff00ff,0,00ffff,0.75")
+    end
+
+    it "should raise an error for invalid value of angle" do
+      lambda { @chart.fill(:gradient, @valid_gradient_values.merge(:angle => "gibberish")) }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error on invalid value for type" do
+      lambda { @chart.fill(:gradient, @valid_gradient_values.merge(:type => :gibberish)) }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error on invalid value for colors" do
+      lambda { @chart.fill(:gradient, @valid_gradient_values.merge(:colors => [nil, 23, "ff00ff"])) }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error on invalid value for offests" do
+      lambda { @chart.fill(:gradient, @valid_gradient_values.merge(:offsets => [nil, 23, "ff00ff"])) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "Stripes" do
+    before(:each) { @valid_stripe_values = {:type => :background, :angle => 45, :colors => ["ff00ff", "00ffff"], :widths => [0.25,0.75]} }
+
+    it "should be able to initialise the properties from within a block" do
+      @chart.fill :stripes do |f|
+        f.type   = :background
+        f.angle  = 45
+        f.colors = ["ff00ff", "00ffff"]
+        f.widths = [0.25,0.75]
+      end
+      @chart.query_params[:chf].should be_eql("bg,ls,45,ff00ff,0.25,00ffff,0.75")
+    end
+
+    it "should be able to initialise the properties via a hash" do
+      @chart.fill(:stripes, @valid_stripe_values)
+      @chart.query_params[:chf].should be_eql("bg,ls,45,ff00ff,0.25,00ffff,0.75")
+    end
+
+    it "should raise an error on invalid value for type" do
+      lambda { @chart.fill(:stripes, @valid_stripe_values.merge(:type => :gibberish)) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error on invalid value for angle" do
+      lambda { @chart.fill(:stripes, @valid_stripe_values.merge(:angle => "gibberish")) }.should raise_error(ArgumentError)
+    end
+
+    it "raise an error on invalid value for colors" do
+      lambda { @chart.fill(:stripes, @valid_stripe_values.merge(:colors => [:gibberish])) }.should raise_error(ArgumentError)
+    end
+
+    it "raise an error on invalid value for widths" do
+      lambda { @chart.fill(:stripes, @valid_stripe_values.merge(:widths => ["hi", "there"])) }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/gchartrb/grid_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GoogleChart::Grid do
+  before(:each) do
+    @chart = GoogleChart::LineChart.new
+    @chart.data "Series 1", [1,2,3,4,5], "ff00ff"
+    @valid_grid_params = { :x_step => 20, :y_step => 50, :line_segment => 1, :blank_segment => 5 }
+  end
+
+  it "is supported by LineChart, LineXYChart, BarChart, ScatterPlot and SparklineChart" do
+    [GoogleChart::LineChart, GoogleChart::LineXYChart,
+    GoogleChart::BarChart, GoogleChart::ScatterPlot, GoogleChart::SparklineChart].each do |klass|
+      klass.new.should respond_to(:grid)
+    end
+  end
+
+  it "should be able to take in values via a hash and generate a correct URL" do
+    @chart.grid(@valid_grid_params)
+    @chart.query_params[:chg].should == "20,50,1,5"
+  end
+
+  it "should be able to take in values via a block and generate a correct URL" do
+    @chart.grid do |g|
+      g.x_step        = 20
+      g.y_step        = 50
+      g.line_segment  = 1
+      g.blank_segment = 5
+    end
+    @chart.query_params[:chg].should == "20,50,1,5"
+  end
+
+  it "should raise an error if any of the values is non numeric" do
+    params = @valid_grid_params.except(:x_step)
+    params[:x_step] = "yo"
+    lambda { @chart.grid(params) }.should raise_error(ArgumentError)
+
+    params = @valid_grid_params.except(:y_step)
+    params[:y_step] = "yo"
+    lambda { @chart.grid(params) }.should raise_error(ArgumentError)
+
+    params = @valid_grid_params.except(:line_segment)
+    params[:line_segment] = "yo"
+    lambda { @chart.grid(params) }.should raise_error(ArgumentError)
+
+    params = @valid_grid_params.except(:blank_segment)
+    params[:blank_segment] = "yo"
+    lambda { @chart.grid(params) }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an error if x_step or y_step are not within 0 to 100" do
+    params = @valid_grid_params.except(:x_step)
+    params[:x_step] = 200
+    lambda { @chart.grid(params) }.should raise_error(ArgumentError)
+
+    params = @valid_grid_params.except(:y_step)
+    params[:y_step] = 200
+    lambda { @chart.grid(params) }.should raise_error(ArgumentError)
+  end
+end

data/spec/gchartrb/line_chart_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GoogleChart::LineChart do
+  before(:each) { @line_chart = GoogleChart::LineChart.new }
+  it "should have the correct type" do
+    @line_chart.chart_type == "lc"
+  end
+
+  it "should initialise the default values" do
+    @line_chart.width.should == 320
+  end
+
+  it "should raise error when the data is not an array of numeric" do
+    lambda { @line_chart.data("Series 1", [[1,2],[2,3]]) }.should raise_error(ArgumentError)
+  end
+
+  it "should add a data and a legend" do
+    @line_chart.data("Series 1", [1,2,3])
+    @line_chart.instance_variable_get("@data").first.should == [1,2,3]
+    @line_chart.instance_variable_get("@legends").first.should == "Series 1"
+  end
+
+  it "should contain a simple set of query parameters after adding data" do
+     @line_chart.title = "Chart"
+     @line_chart.data("Series 1", [1,1,1])
+
+     @line_chart.query_params[:cht].should == "lc"
+     @line_chart.query_params[:chtt].should == "Chart"
+     @line_chart.query_params[:chd].should == "s:999"
+     @line_chart.query_params[:chs].should == "320x200"
+
+     @line_chart.data("Series 2", [2,2,2])
+     @line_chart.query_params[:chd].should == "s:fff,999"
+  end
+
+  it "should render the URL properly when to_url is called" do
+    @line_chart.data("Series 1", [1,1,1])
+    query_string_to_hash(@line_chart.to_url)[:chd].should == "s:999"
+    query_string_to_hash(@line_chart.to_url)[:cht].should == "lc"
+  end
+
+  it "should accept extra parameters in the to_url method" do
+    @line_chart.data("Series 1", [1,1,1])
+    query_string_to_hash(@line_chart.to_url(:chtt => "test"))[:chtt].should == "test"
+  end
+
+  it "should replace newline in title to pipe" do
+    @line_chart.title="test\nnewline"
+    @line_chart.title.should == "test|newline"
+  end
+
+  it "should show legend if the show_legend attribute is set to true" do
+    @line_chart.data("Series", [1,2,3])
+    @line_chart.show_legend = true
+    @line_chart.query_params[:chdl].should_not be_nil
+  end
+
+  it "should not show legend if show_legend attribute is set to true but legends are nil" do
+    @line_chart.data("Test", [1,2,3])
+    @line_chart.data(nil, [1,2,3])
+    @line_chart.show_legend = true
+    @line_chart.query_params[:chdl].should == "Test|"
+  end
+
+  it "should have legend support" do
+    @line_chart.respond_to?(:legend, true).should be_true
+  end
+
+  it "should have color support" do
+    @line_chart.respond_to?(:color, true).should be_true
+  end
+
+  it "should have the max attribute defined" do
+    @line_chart.should respond_to(:max)
+    @line_chart.should_not respond_to(:max_x)
+    @line_chart.should_not respond_to(:max_y)
+  end
+end

data/spec/gchartrb/linexy_chart_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GoogleChart::LineXYChart do
+  before(:each) { @linexy_chart = GoogleChart::LineXYChart.new }
+  it "should have the correct type" do
+    @linexy_chart.chart_type == "lxy"
+  end
+
+  it "should not accept a one dimensional array as input" do
+    lambda { @linexy_chart.data("Series 1",[1,2,3,4,5]) }.should raise_error(ArgumentError)
+    lambda { @linexy_chart.data("Series 1",[1,[2,3],3,4,5]) }.should raise_error(ArgumentError)
+    lambda { @linexy_chart.data("Series 1",[[1,2],[2,"a"]]) }.should raise_error(ArgumentError)
+    lambda { @linexy_chart.data("Series 1",[[1,2],[2,3]]) }.should_not raise_error(ArgumentError)
+  end
+
+  it "should have legend support" do
+    @linexy_chart.respond_to?(:legend, true).should be_true
+  end
+
+  it "should process X and Y values correctly" do
+    @linexy_chart.data("Series 1",[[1,1],[2,2]])
+    @linexy_chart.query_params[:chd].should == "s:f9,f9"
+  end
+
+  it "should have a max_x and a max_y value defined" do
+    @linexy_chart.should respond_to(:max_x)
+    @linexy_chart.should respond_to(:max_y)
+    @linexy_chart.should_not respond_to(:max)
+  end
+
+end

data/spec/gchartrb/markers_spec.rb

@@ -0,0 +1,160 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GoogleChart::Markers do
+  before(:each) do
+    @chart = GoogleChart::LineChart.new
+    @chart.data "Series 1", [1,2,3,4,5], "ff00ff"
+  end
+
+ it "is supported by LineChart, LineXYChart, BarChart, ScatterPlot and SparklineChart" do
+    [GoogleChart::LineChart, GoogleChart::LineXYChart,
+    GoogleChart::BarChart, GoogleChart::ScatterPlot, GoogleChart::SparklineChart].each do |klass|
+      klass.new.should respond_to(:shape_marker)
+      klass.new.should respond_to(:range_marker)
+    end
+  end
+
+  describe ".shape_marker" do
+    before(:each) { @valid_shape_marker = { :color => "ff00ff", :data_set => 0, :data_point => 1, :size => 4, :priority => :low } }
+
+    it "should be able to initialise the marker with an orientation and options hash" do
+      @chart.shape_marker(:arrow, @valid_shape_marker)
+      @chart.query_params[:chm].should == "a,ff00ff,0,1,4,-1"
+    end
+
+    it "should be able to initialise the marker with an orientation and block passed in" do
+      @chart.shape_marker(:arrow) do |marker|
+        marker.color = "ff00ff"
+        marker.data_set = 0
+        marker.data_point = 1
+        marker.size = 4
+        marker.priority = :low
+      end
+      @chart.query_params[:chm].should == "a,ff00ff,0,1,4,-1"
+    end
+
+    it "should raise an error if the shape is invalid" do
+      lambda { @chart.shape_marker(:gibberish,@valid_shape_marker) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if color is not a string" do
+      params = @valid_shape_marker.except(:color)
+      params[:color] = :hi
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if data set is not an integer and is greater than the available number of data sets" do
+      params = @valid_shape_marker.except(:data_set)
+      params[:data_set] = 1
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+
+      params[:data_set] = -1
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+
+      params[:data_set] = "hi"
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if data point is not an integer and is greater than the available number of data points for the data set" do
+      params = @valid_shape_marker.except(:data_point)
+      params[:data_point] = 5
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+
+      params[:data_point] = -1
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+
+      params[:data_point] = "hi"
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should  raise error if the priority is not :low or :high" do
+      params = @valid_shape_marker.except(:priority)
+      params[:priority] = 5
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should not raise error if the priority is nil" do
+      params = @valid_shape_marker.except(:priority)
+      params[:priority] = nil
+      lambda { @chart.shape_marker(:arrow,params) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should raise error if size is not an integer" do
+      params = @valid_shape_marker.except(:size)
+      params[:size] = "hi"
+      lambda { @chart.shape_marker(:arrow,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a text option for a text marker" do
+      @chart.shape_marker(:text, @valid_shape_marker.merge(:text => "Hi There"))
+    end
+
+    it "should not accept a text option for a text marker" do
+      lambda { @chart.shape_marker(:arrow, @valid_shape_marker.merge(:text => "Hi There")) }.should raise_error(ArgumentError)
+    end
+
+    it "should format the text marker correctly" do
+      @chart.shape_marker(:text, @valid_shape_marker.merge(:text => "Hi There"))
+      @chart.query_params[:chm].should == "tHi+There,ff00ff,0,1,4,-1"
+    end
+
+  end
+
+  describe ".range_marker" do
+
+    before(:each) { @valid_range_marker = {:color => "ff00ff", :start => 0.5, :end => 0.7} }
+
+    it "should be able to initialise the marker with an orientation and options hash" do
+      @chart.range_marker(:vertical,@valid_range_marker)
+      @chart.query_params[:chm].should == "R,ff00ff,0,0.5,0.7"
+    end
+
+    it "should be able to initialise the marker with an orientation and block passed in" do
+      @chart.range_marker(:horizontal) do |marker|
+        marker.color = "ff00ff"
+        marker.start = 0.5
+        marker.end   = 0.7
+      end
+
+      @chart.query_params[:chm].should == "r,ff00ff,0,0.5,0.7"
+    end
+
+    it "should raise error if the orientation is invalid" do
+      lambda { @chart.range_marker(:gibberish,@valid_range_marker) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if color is not a string" do
+      params = @valid_range_marker.except(:color)
+      params[:color] = nil
+      lambda { @chart.range_marker(:vertical,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if start and end are not numeric" do
+      params = @valid_range_marker.except(:start)
+      params[:start] = "hi"
+      lambda { @chart.range_marker(:vertical,params) }.should raise_error(ArgumentError)
+
+      params = @valid_range_marker.except(:end)
+      params[:end] = "hi"
+      lambda { @chart.range_marker(:vertical,params) }.should raise_error(ArgumentError)
+    end
+
+
+    it "should raise error if start and end are not within 0 and 1" do
+      params = @valid_range_marker.except(:start)
+      params[:start] = -1
+      lambda { @chart.range_marker(:vertical,params) }.should raise_error(ArgumentError)
+
+      params = @valid_range_marker.except(:end)
+      params[:end] = 5
+      lambda { @chart.range_marker(:vertical,params) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if end < start" do
+      params = @valid_range_marker.except(:start, :end)
+      params[:start] = 0.9
+      params[:end]   = 0.7
+      lambda { @chart.range_marker(:vertical,params) }.should raise_error(ArgumentError)
+    end
+  end
+end