xively-rb 0.2.09

data/spec/xively-rb/parsers/xml/key_defaults_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "default key xml parser" do
+  it "should convert into attributes hash" do
+    @xml = key_as_(:xml)
+    Xively::Key.new(@xml).should fully_represent_key(:xml, @xml)
+  end
+
+  Xively::Key::ALLOWED_KEYS.each do |key|
+    it "should handle blank '#{key}'" do
+      @xml = key_as_(:xml, :except_node => :referer)
+      Xively::Key.new(@xml).should fully_represent_key(:xml, @xml)
+    end
+  end
+
+  it "should raise known exception if passed garbage as xml" do
+    expect {
+      Xively::Key.new("This is not XML", :xml)
+    }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+  end
+end
+

data/spec/xively-rb/parsers/xml/trigger_defaults_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "default trigger xml parser" do
+  it "should convert into attributes hash" do
+    @xml = trigger_as_(:xml)
+    Xively::Trigger.new(@xml).should fully_represent_trigger(:xml, @xml)
+  end
+
+  Xively::Trigger::ALLOWED_KEYS.each do |key|
+    it "should handle blank '#{key}'" do
+      @xml = trigger_as_(:xml, :except_node => :at)
+      Xively::Trigger.new(@xml).should fully_represent_trigger(:xml, @xml)
+    end
+  end
+
+  it "should raise known exception if passed garbage as xml" do
+    expect {
+      Xively::Trigger.new("This is not XML", :xml)
+    }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+  end
+end
+

data/spec/xively-rb/search_result_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+class CustomPachubeFeed < Xively::Feed
+end
+
+describe Xively::SearchResult do
+
+  it "should have a constant that defines the allowed keys" do
+    Xively::SearchResult::ALLOWED_KEYS.should == %w(totalResults startIndex itemsPerPage results)
+  end
+
+
+  context "attr accessors" do
+    before(:each) do
+      @search_result = Xively::SearchResult.new(:results => [feed_as_(:json), feed_as_(:hash)])
+    end
+
+    describe "setting whitelisted fields" do
+      Xively::SearchResult::ALLOWED_KEYS.each do |key|
+        it "##{key}=" do
+          lambda {
+            @search_result.send("#{key}=", key)
+          }.should_not raise_error
+        end
+      end
+    end
+
+    describe "getting whitelisted fields" do
+      Xively::SearchResult::ALLOWED_KEYS.each do |key|
+        it "##{key}" do
+          lambda {
+            @search_result.send(key)
+          }.should_not raise_error
+        end
+      end
+    end
+
+    describe "setting non-whitelisted keys" do
+      it "should not be possible to set non-whitelisted fields" do
+        lambda {
+          @search_result.something_bogus = 'whatevs'
+        }.should raise_error
+      end
+
+      it "should not be possible to get non-whitelisted fields" do
+        lambda {
+          @search_result.something_bogus
+        }.should raise_error
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "should create a blank slate when passed no arguments" do
+      search_result = Xively::SearchResult.new
+      Xively::SearchResult::ALLOWED_KEYS.each do |attr|
+        search_result.attributes[attr.to_sym].should be_nil
+      end
+    end
+
+    it "should accept a hash of attributes" do
+      search_result = Xively::SearchResult.new("totalResults" => 1000, "results" => [feed_as_(:hash)])
+      search_result.totalResults.should == 1000
+      search_result.results.length.should == 1
+    end
+
+    it "should accept json" do
+      search_result = Xively::SearchResult.new(search_result_as_(:json))
+      search_result.totalResults.should == "10000"
+      search_result.itemsPerPage.should == "100"
+      search_result.startIndex.should == "0"
+      search_result.results.length.should == 1
+    end
+
+    it "should accept json with no datastreams within the feeds" do
+      json = %Q(
+        {\"totalResults\":33,\"startIndex\":0,\"results\":[{\"status\":\"frozen\",\"version\":\"1.0.0\",\"updated\":\"2011-05-19T09:50:39.940513Z\",\"title\":\"No map\",\"private\":\"false\",\"feed\":\"http://api.appdev.loc/v2/feeds/79.json\",\"id\":79,\"creator\":\"http://appdev.loc/users/lebreeze\"},{\"status\":\"frozen\",\"location\":{\"lon\":18.28125,\"lat\":28.3043806829628,\"domain\":\"physical\"},\"version\":\"1.0.0\",\"description\":\"Description\",\"updated\":\"2011-05-18T13:25:02.112395Z\",\"title\":\"Title\",\"private\":\"false\",\"feed\":\"http://api.appdev.loc/v2/feeds/78.json\",\"id\":78,\"creator\":\"http://appdev.loc/users/lebreeze\"},{\"status\":\"frozen\",\"location\":{\"exposure\":\"outdoor\",\"domain\":\"physical\",\"disposition\":\"mobile\"},\"version\":\"1.0.0\",\"updated\":\"2011-05-04T12:12:07.352590Z\",\"title\":\"nope\",\"private\":\"false\",\"feed\":\"http://api.appdev.loc/v2/feeds/77.json\",\"id\":77,\"creator\":\"http://appdev.loc/users/lebreeze\"}],\"itemsPerPage\":3}
+)
+      search_result = Xively::SearchResult.new(json)
+      search_result.results.length.should == 3
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of search result properties" do
+      attrs = {}
+      Xively::SearchResult::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["results"] = [Xively::Feed.new({"id" => "ein"})]
+      search_result = Xively::SearchResult.new(attrs)
+
+      search_result.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Xively::SearchResult::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["totalResults"] = nil
+      search_result = Xively::Feed.new(attrs)
+
+      search_result.attributes.should_not include("totalResults")
+    end
+  end
+
+  describe "#attributes=" do
+    it "should accept and save a hash of feed properties" do
+      search_result = Xively::SearchResult.new({})
+
+      attrs = {}
+      Xively::SearchResult::ALLOWED_KEYS.each do |key|
+        value = "key #{rand(1000)}"
+        attrs[key] = value
+        search_result.should_receive("#{key}=").with(value)
+      end
+      search_result.attributes=(attrs)
+    end
+  end
+
+  context "associated feeds" do
+
+    describe "#results" do
+      it "should return an array of feeds" do
+        feeds = [Xively::Feed.new(feed_as_(:hash))]
+        attrs = {"results" => feeds}
+        search_result = Xively::SearchResult.new(attrs)
+        search_result.results.each do |env|
+          env.should be_kind_of(Xively::Feed)
+        end
+      end
+
+
+      it "should allow overriding the feed class to use" do
+        Xively::SearchResult.class_eval("@@feed_class = CustomPachubeFeed")
+        feeds = [feed_as_(:hash)]
+        attrs = {"results" => feeds}
+        search_result = Xively::SearchResult.new(attrs)
+        search_result.results.each do |env|
+          env.should be_kind_of(CustomPachubeFeed)
+        end
+        Xively::SearchResult.class_eval("@@feed_class = Xively::Feed")
+      end
+    end
+
+    describe "#results=" do
+      before(:each) do
+        @search_result = Xively::SearchResult.new({})
+      end
+
+      it "should return [] if not an array" do
+        @search_result.results = "kittens"
+        @search_result.results.should be_empty
+      end
+
+      it "should accept an array of feeds and hashes and store an array of datastreams" do
+        new_feed1 = Xively::Feed.new(feed_as_(:hash))
+        new_feed2 = Xively::Feed.new(feed_as_(:hash))
+        Xively::Feed.should_receive(:new).with(feed_as_(:hash)).and_return(new_feed2)
+
+        feeds = [new_feed1, feed_as_(:hash)]
+        @search_result.results = feeds
+        @search_result.results.length.should == 2
+        @search_result.results.should include(new_feed1)
+        @search_result.results.should include(new_feed2)
+      end
+
+      it "should accept an array of feeds and store an array of feeds" do
+        feeds = [Xively::Feed.new(feed_as_(:hash))]
+        @search_result.results = feeds
+        @search_result.results.should == feeds
+      end
+
+      it "should accept an array of hashes and store an array of feeds" do
+        new_feed = Xively::Feed.new(feed_as_(:hash))
+        Xively::Feed.should_receive(:new).with(feed_as_(:hash)).and_return(new_feed)
+
+        feeds_hash = [feed_as_(:hash)]
+        @search_result.results = feeds_hash
+        @search_result.results.should == [new_feed]
+      end
+    end
+
+  end
+
+  # Provided by Xively::Templates::SearchResultDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      search_result = Xively::SearchResult.new({"totalResults" => 100, "itemsPerPage" => 12, :results => []})
+      search_result.generate_json("1.0.0").should == {:totalResults => 100, :itemsPerPage => 12}
+    end
+  end
+
+  describe "#to_xml" do
+    it "should call the xml generator with default version" do
+      search_result = Xively::SearchResult.new({})
+      search_result.should_receive(:generate_xml).with("0.5.1").and_return("<xml></xml>")
+      search_result.to_xml.should == "<xml></xml>"
+    end
+
+    it "should accept optional xml version" do
+      version = "5"
+      search_result = Xively::SearchResult.new({})
+      search_result.should_receive(:generate_xml).with(version).and_return("<xml></xml>")
+      search_result.to_xml(:version => version).should == "<xml></xml>"
+    end
+  end
+
+  describe "#as_json" do
+    it "should call the json generator with default version" do
+      search_result = Xively::SearchResult.new({})
+      search_result.should_receive(:generate_json).with("1.0.0").and_return({"title" => "Feed"})
+      search_result.as_json.should == {"title" => "Feed"}
+    end
+
+    it "should accept optional json version" do
+      version = "0.6-alpha"
+      search_result = Xively::SearchResult.new({})
+      search_result.should_receive(:generate_json).with(version).and_return({"title" => "Feed"})
+      search_result.as_json(:version => version).should == {"title" => "Feed"}
+    end
+  end
+
+  describe "#to_json" do
+    it "should call #as_json" do
+      search_result_hash = {"totalResults" => 100}
+      search_result = Xively::SearchResult.new(search_result_hash)
+      search_result.should_receive(:as_json).with({})
+      search_result.to_json
+    end
+
+    it "should pass options through to #as_json" do
+      search_result_hash = {"totalResults" => 100}
+      search_result = Xively::SearchResult.new(search_result_hash)
+      search_result.should_receive(:as_json).with({:crazy => "options"})
+      search_result.to_json({:crazy => "options"})
+    end
+
+    it "should generate feeds" do
+      search_result = Xively::SearchResult.new("results" => [feed_as_('hash')])
+      search_result.results = feed_as_(:hash)
+      MultiJson.load(search_result.to_json)["results"].should_not be_nil
+    end
+
+    it "should pass the output of #as_json to yajl" do
+      search_result_hash = {"totalResults" => 100}
+      search_result = Xively::SearchResult.new(search_result_hash)
+      search_result.should_receive(:as_json).and_return({:awesome => "hash"})
+      MultiJson.should_receive(:dump).with({:awesome => "hash"})
+      search_result.to_json
+    end
+  end
+
+
+end
+

data/spec/xively-rb/string_extensions_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "String extensions" do
+
+  # HACK!!!!
+  it "should fail silently if iso8601 called on a non-time object" do
+    time_string = "2011-02-16T16:21:01.834174Z"
+    time_string.iso8601.should == time_string
+    time_string.iso8601(6).should == time_string
+  end
+end
+

data/spec/xively-rb/templates/csv/datapoint_defaults_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "default datapoint json templates" do
+  before(:each) do
+    @datapoint = Xively::Datapoint.new(datapoint_as_(:hash).merge("feed_id" => 6545, "datastream_id" => 0))
+  end
+
+  it "should represent Pachube datapoints (only used by API v2)" do
+    csv = @datapoint.generate_csv("2")
+    csv.should == @datapoint.value
+  end
+
+  it "should accept a depth option" do
+    csv = @datapoint.generate_csv("2", :depth => 1)
+    csv.should == @datapoint.value
+    csv = @datapoint.generate_csv("2", :depth => 2)
+    csv.should == [@datapoint.at.iso8601(6),@datapoint.value].join(',')
+    csv = @datapoint.generate_csv("2", :depth => 3)
+    csv.should == [@datapoint.datastream_id, @datapoint.at.iso8601(6),@datapoint.value].join(',')
+    csv = @datapoint.generate_csv("2", :depth => 4)
+    csv.should == [@datapoint.feed_id, @datapoint.datastream_id, @datapoint.at.iso8601(6), @datapoint.value].join(',')
+  end
+
+  it "should have an optional full representation" do
+    csv = @datapoint.generate_csv("2", :full => true)
+    csv.should == [@datapoint.feed_id, @datapoint.datastream_id, @datapoint.at.iso8601(6), @datapoint.value].join(',')
+  end
+
+  it "should escape stuff that could upset csv parsers" do
+    @datapoint.value = "I \n , am not a csv"
+    csv = @datapoint.generate_csv("2")
+    csv.should == Xively::CSV.generate_line([@datapoint.value]).strip
+  end
+
+  it "should escape characters that could upset csv parsers via full" do
+    @datapoint.value = "I \n , am not a csv"
+    csv = @datapoint.generate_csv("2", :full => true)
+    csv.should == Xively::CSV.generate_line([@datapoint.feed_id, @datapoint.datastream_id, @datapoint.at.iso8601(6), @datapoint.value]).strip
+  end
+end
+

data/spec/xively-rb/templates/csv/datastream_defaults_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe "default datastream json templates" do
+  before(:each) do
+    @datastream = Xively::Datastream.new(datastream_as_(:hash))
+  end
+
+  context "version 2 (used by API V2)" do
+
+    it "should default to 2" do
+      @datastream.generate_csv("2").should == @datastream.to_csv
+    end
+
+    it "should only show datapoints if there are any" do
+      csv = @datastream.generate_csv("2")
+      csv.should == @datastream.datapoints.collect {|dp| "#{dp.at.iso8601(6)},#{dp.value}"}.join("\n")
+    end
+
+    it "should represent datastream in Pachube CSV v2 if no datapoints" do
+      @datastream.datapoints = []
+      csv = @datastream.generate_csv("2")
+      csv.should == "#{@datastream.updated.iso8601(6)},#{@datastream.current_value}"
+    end
+
+    context "depth" do
+      it "should allow representation of datastream at depth 4" do
+        @datastream.datapoints = []
+        csv = @datastream.generate_csv("2", :depth => 4)
+        csv.should == "#{@datastream.feed_id},#{@datastream.id},#{@datastream.updated.iso8601(6)},#{@datastream.current_value}"
+      end
+
+      it "should allow representation of datapoints at depth 4" do
+        csv = @datastream.generate_csv("2", :depth => 4)
+        csv.should == @datastream.datapoints.collect {|dp| "#{@datastream.feed_id},#{@datastream.id},#{dp.at.iso8601(6)},#{dp.value}"}.join("\n")
+      end
+
+      it "should allow representation of datastream at depth 4" do
+        @datastream.datapoints = []
+        csv = @datastream.generate_csv("2", :depth => 3)
+        csv.should == "#{@datastream.id},#{@datastream.updated.iso8601(6)},#{@datastream.current_value}"
+      end
+
+      it "should allow representation of datapoints at depth 4" do
+        csv = @datastream.generate_csv("2", :depth => 3)
+        csv.should == @datastream.datapoints.collect {|dp| "#{@datastream.id},#{dp.at.iso8601(6)},#{dp.value}"}.join("\n")
+      end
+
+      it "should allow representation of datastream at depth 4" do
+        @datastream.datapoints = []
+        csv = @datastream.generate_csv("2", :depth => 2)
+        csv.should == "#{@datastream.updated.iso8601(6)},#{@datastream.current_value}"
+      end
+
+      it "should allow representation of datapoints at depth 4" do
+        csv = @datastream.generate_csv("2", :depth => 2)
+        csv.should == @datastream.datapoints.collect {|dp| "#{dp.at.iso8601(6)},#{dp.value}"}.join("\n")
+      end
+
+      it "should allow representation of datastream at depth 4" do
+        @datastream.datapoints = []
+        csv = @datastream.generate_csv("2", :depth => 1)
+        csv.should == "#{@datastream.current_value}"
+      end
+
+      it "should allow representation of datapoints at depth 4" do
+        csv = @datastream.generate_csv("2", :depth => 1)
+        csv.should == @datastream.datapoints.collect {|dp| "#{dp.value}"}.join("\n")
+      end
+
+    end
+
+
+    it "should allow a full representation of datastream" do
+      @datastream.datapoints = []
+      csv = @datastream.generate_csv("2", :full => true)
+      csv.should == "#{@datastream.feed_id},#{@datastream.id},#{@datastream.updated.iso8601(6)},#{@datastream.current_value}"
+    end
+
+    it "should allow a full representation of datapoints" do
+      csv = @datastream.generate_csv("2", :full => true)
+      csv.should == @datastream.datapoints.collect {|dp| "#{@datastream.feed_id},#{@datastream.id},#{dp.at.iso8601(6)},#{dp.value}"}.join("\n")
+    end
+
+    it "should escape characters that could upset csv parsers without datapoints" do
+      @datastream.current_value = "one,field"
+      @datastream.datapoints = []
+      csv = @datastream.generate_csv("2")
+      csv.should == Xively::CSV.generate_line([@datastream.updated.iso8601(6),@datastream.current_value]).strip
+    end
+
+    it "should escape characters that could upset csv parsers with datapoints" do
+      @datastream.current_value = "one,field"
+      @datastream.datapoints.each do |dp|
+        dp.value = "1,field"
+      end
+      csv = @datastream.generate_csv("2")
+      csv.should == @datastream.datapoints.collect {|dp| Xively::CSV.generate_line([dp.at.iso8601(6),dp.value]).strip }.join("\n")
+    end
+
+    it "should escape characters that could upset csv parsers without datapoints via full" do
+      @datastream.current_value = "one,field"
+      @datastream.datapoints = []
+      csv = @datastream.generate_csv("2", :full => true)
+      csv.should == Xively::CSV.generate_line([@datastream.feed_id,@datastream.id,@datastream.updated.iso8601(6),@datastream.current_value]).strip
+    end
+
+    it "should escape characters that could upset csv parsers with datapoints via full" do
+      @datastream.current_value = "one,field"
+      @datastream.datapoints.each do |dp|
+        dp.value = "1,field"
+      end
+      csv = @datastream.generate_csv("2", :full => true)
+      csv.should == @datastream.datapoints.collect {|dp| Xively::CSV.generate_line([@datastream.feed_id,@datastream.id,dp.at.iso8601(6),dp.value]).strip }.join("\n")
+    end
+  end
+
+  context "version 1 (used by API V1)" do
+
+    it "should represent Pachube CSV v1" do
+      csv = @datastream.generate_csv("1")
+      csv.should == @datastream.current_value
+    end
+
+    it "should escape characters that could upset csv parsers" do
+      @datastream.current_value = "I \n am full of c,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, evil"
+      csv = @datastream.generate_csv("1")
+      csv.should == Xively::CSV.generate_line([@datastream.current_value]).strip
+    end
+  end
+end
+