cosm-rb 0.0.1

data/spec/cosm-rb/search_result_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+class CustomPachubeFeed < Cosm::Feed
+end
+
+describe Cosm::SearchResult do
+
+  it "should have a constant that defines the allowed keys" do
+    Cosm::SearchResult::ALLOWED_KEYS.should == %w(totalResults startIndex itemsPerPage results)
+  end
+
+
+  context "attr accessors" do
+    before(:each) do
+      @search_result = Cosm::SearchResult.new(:results => [feed_as_(:json), feed_as_(:hash)])
+    end
+
+    describe "setting whitelisted fields" do
+      Cosm::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
+      Cosm::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 = Cosm::SearchResult.new
+      Cosm::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 = Cosm::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 = Cosm::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 = Cosm::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 = {}
+      Cosm::SearchResult::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["results"] = [Cosm::Feed.new({"id" => "ein"})]
+      search_result = Cosm::SearchResult.new(attrs)
+
+      search_result.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Cosm::SearchResult::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["totalResults"] = nil
+      search_result = Cosm::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 = Cosm::SearchResult.new({})
+
+      attrs = {}
+      Cosm::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 = [Cosm::Feed.new(feed_as_(:hash))]
+        attrs = {"results" => feeds}
+        search_result = Cosm::SearchResult.new(attrs)
+        search_result.results.each do |env|
+          env.should be_kind_of(Cosm::Feed)
+        end
+      end
+
+
+      it "should allow overriding the feed class to use" do
+        Cosm::SearchResult.class_eval("@@feed_class = CustomPachubeFeed")
+        feeds = [feed_as_(:hash)]
+        attrs = {"results" => feeds}
+        search_result = Cosm::SearchResult.new(attrs)
+        search_result.results.each do |env|
+          env.should be_kind_of(CustomPachubeFeed)
+        end
+        Cosm::SearchResult.class_eval("@@feed_class = Cosm::Feed")
+      end
+    end
+
+    describe "#results=" do
+      before(:each) do
+        @search_result = Cosm::SearchResult.new({})
+      end
+
+      it "should return nil if not an array" do
+        @search_result.results = "kittens"
+        @search_result.results.should be_nil
+      end
+
+      it "should accept an array of feeds and hashes and store an array of datastreams" do
+        new_feed1 = Cosm::Feed.new(feed_as_(:hash))
+        new_feed2 = Cosm::Feed.new(feed_as_(:hash))
+        Cosm::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 = [Cosm::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 = Cosm::Feed.new(feed_as_(:hash))
+        Cosm::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 Cosm::Templates::SearchResultDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      search_result = Cosm::SearchResult.new({})
+      Cosm::Template.should_receive(:new).with(search_result, :json)
+      lambda {search_result.generate_json("1.0.0")}.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "#to_xml" do
+    it "should call the xml generator with default version" do
+      search_result = Cosm::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 = Cosm::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 = Cosm::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 = Cosm::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 = Cosm::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 = Cosm::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 = Cosm::SearchResult.new("results" => [feed_as_('hash')])
+      search_result.results = feed_as_(:hash)
+      JSON.parse(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 = Cosm::SearchResult.new(search_result_hash)
+      search_result.should_receive(:as_json).and_return({:awesome => "hash"})
+      ::JSON.should_receive(:generate).with({:awesome => "hash"})
+      search_result.to_json
+    end
+  end
+
+
+end
+

data/spec/cosm-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/cosm-rb/template_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Cosm::Template do
+  describe "initialisation" do
+    it "should accept an object and format" do
+      template = Cosm::Template.new(@feed, :json)
+      template.subject.should == @feed
+      template.presentation.should == :json
+    end
+  end
+
+  describe "presenting json" do
+    before(:each) do
+      @feed = Cosm::Feed.new(feed_as_(:hash))
+      @template = Cosm::Template.new(@feed, :json)
+    end
+
+    it "should allow describing :title => @feed.title" do
+      @template.title
+      @template.output!.should == {:title => @feed.title}
+    end
+
+    it "should allow describing :name => @feed.title" do
+      @template.name {title}
+      @template.output!.should == {:name => @feed.title}
+    end
+
+    it "should allow describing :tags => @feed.tags.map(&:strip).sort" do
+      @template.tags { [*tags].map(&:strip).sort }
+      @template.output!.should == {:tags => [*@feed.tags].map(&:strip).sort}
+    end
+
+    it "should allow describing datastreams" do
+      @template.title
+      @template.datastreams do |f|
+        f.datastreams.collect do |ds|
+          {
+            :id => ds.id,
+            :current_value => ds.current_value
+          }
+        end
+      end
+      datastreams = @feed.datastreams.collect {|ds| {:id => ds.id, :current_value => ds.current_value}}
+      @template.output!.should == {
+        :title => @feed.title,
+        :datastreams => datastreams
+      }
+    end
+
+    it "should ignore nils" do
+      @feed.title = nil
+      @template.title
+      @template.output!.should == {}
+    end
+
+    it "should return nils for NameErrors" do
+      @template.title {litter}
+      @template.output!.should == {}
+    end
+
+    it "should return nils for NoMethodErrors" do
+      @feed.should_not respond_to(:rubbish)
+      @template.rubbish.should == nil
+    end
+
+    it "should include blanks if we pass :include_blank" do
+      @feed.title = ''
+      @template.title
+      @template.output!(:include_blank => true).should == {:title => ''}
+    end
+
+  end
+end
+

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "default datapoint json templates" do
+  before(:each) do
+    @datapoint = Cosm::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 == 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 == CSV.generate_line([@datapoint.feed_id, @datapoint.datastream_id, @datapoint.at.iso8601(6), @datapoint.value]).strip
+  end
+end
+

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe "default datastream json templates" do
+  before(:each) do
+    @datastream = Cosm::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 == 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| 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 == 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| 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 == CSV.generate_line([@datastream.current_value]).strip
+    end
+  end
+end
+

data/spec/cosm-rb/templates/csv/feed_defaults_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "default feed json templates" do
+  before(:each) do
+    @feed = Cosm::Feed.new(feed_as_(:hash))
+    @feed.datastreams.each do |ds|
+      ds.current_value = "I \n , will , break , you"
+      ds.datapoints.each do |dp|
+        dp.value = "one,data,point"
+      end
+    end
+  end
+
+  context "2 (used by API v2)" do
+    it "should be the default" do
+      @feed.generate_csv("2").should == @feed.to_csv
+    end
+
+    it "should represent Pachube JSON" do
+      @feed.datastreams.each do |ds|
+        ds.datapoints = []
+      end
+      csv = @feed.generate_csv("2")
+      expected_csv = @feed.datastreams.collect do |datastream|
+        CSV.generate_line([datastream.id, datastream.updated.iso8601(6), datastream.current_value]).strip
+      end.join("\n")
+      csv.should == expected_csv
+    end
+
+    it "should allow representing full Pachube JSON" do
+      @feed.datastreams.each do |ds|
+        ds.datapoints = []
+      end
+      csv = @feed.generate_csv("2", :full => true)
+      expected_csv = @feed.datastreams.collect do |datastream|
+        CSV.generate_line([@feed.id, datastream.id, datastream.updated.iso8601(6), datastream.current_value]).strip
+      end.join("\n")
+      csv.should == expected_csv
+    end
+
+    it "should represent Pachube JSON with datapoints" do
+      csv = @feed.generate_csv("2")
+      expected_csv = @feed.datastreams.collect do |datastream|
+        if datastream.datapoints.any?
+          datastream.datapoints.collect {|dp| CSV.generate_line([datastream.id, dp.at.iso8601(6), dp.value]).strip }
+        else
+          CSV.generate_line([datastream.id, datastream.updated.iso8601(6), datastream.current_value]).strip
+        end
+      end.join("\n")
+      csv.should == expected_csv
+    end
+
+    it "should allow representing full Pachube JSON with datapoints" do
+      csv = @feed.generate_csv("2", :full => true)
+      expected_csv = @feed.datastreams.collect do |datastream|
+        if datastream.datapoints.any?
+          datastream.datapoints.collect {|dp| CSV.generate_line([@feed.id, datastream.id, dp.at.iso8601(6), dp.value]).strip }
+        else
+          CSV.generate_line([@feed.id, datastream.id, datastream.updated.iso8601(6), datastream.current_value]).strip
+        end
+      end.join("\n")
+      csv.should == expected_csv
+    end
+  end
+
+  context "0.6-alpha (used by API v1)" do
+
+    it "should represent Pachube JSON" do
+      csv = @feed.generate_csv("1")
+      expected_csv = @feed.datastreams.collect do |datastream|
+        CSV.generate_line([datastream.current_value]).strip
+      end.join(",")
+      csv.should == expected_csv
+    end
+
+  end
+end
+

data/spec/cosm-rb/templates/json/datapoint_defaults_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "default datapoint json templates" do
+  before(:each) do
+    @datapoint = Cosm::Datapoint.new(datapoint_as_(:hash))
+  end
+
+  it "should represent Pachube datapoints (only used by API v2)" do
+    json = @datapoint.generate_json
+    json[:value].should == @datapoint.value
+    json[:at].should == @datapoint.at.iso8601(6)
+  end
+end
+