cosm-rb 0.0.1

data/spec/cosm-rb/datastream_spec.rb

@@ -0,0 +1,301 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Cosm::Datastream do
+
+  it "should have a constant that defines the allowed keys" do
+    Cosm::Datastream::ALLOWED_KEYS.should == %w(feed_id id feed_creator current_value datapoints max_value min_value tags unit_label unit_symbol unit_type updated datapoints_function)
+  end
+
+  describe "validation" do
+    before(:each) do
+      @datastream = Cosm::Datastream.new
+    end
+
+    %w(id).each do |field|
+      it "should require a '#{field}'" do
+        @datastream.send("#{field}=".to_sym, nil)
+        @datastream.should_not be_valid
+        @datastream.errors[field.to_sym].should include("can't be blank")
+      end
+    end
+
+    ["red hat", "foo*", "KYB:FOO"].each do |invalid_id|
+      it "should not allow '#{invalid_id}' as an id" do
+        @datastream.id = invalid_id
+        @datastream.should_not be_valid
+        @datastream.errors[:id].should include("is invalid")
+      end
+    end
+
+    ["üöäÜÖÄ", "ÜÖÄ", "üöä", "current_to_direction-degrees_true-1", "current_to_direction.degrees_true.1"].each do |valid_id|
+      it "should allow '#{valid_id}' as an id" do
+        @datastream.feed_id = 1234
+        @datastream.id = valid_id
+        @datastream.should be_valid
+        @datastream.errors[:id].should be_empty
+      end
+    end
+
+    ["red hat", "foo*", 12.05].each do |invalid_feed_id|
+      it "should not allow '#{invalid_feed_id}' as a feed_id" do
+        @datastream.id = "1"
+        @datastream.feed_id = invalid_feed_id
+        @datastream.should_not be_valid
+        @datastream.errors[:feed_id].should include("is invalid")
+      end
+    end
+
+    [0, 1234, 102931203, "123"].each do |valid_feed_id|
+      it "should allow '#{valid_feed_id}' as a feed_id" do
+        @datastream.id = "1"
+        @datastream.feed_id = valid_feed_id
+        @datastream.should be_valid
+        @datastream.errors[:feed_id].should be_empty
+      end
+    end
+
+    %w(current_value tags).each do |field|
+      it "should restrict '#{field}' field length to 255" do
+        @datastream.send("#{field}=".to_sym, "a"*256)
+        @datastream.should_not be_valid
+        @datastream.errors[field.to_sym].should == ["is too long (maximum is 255 characters)"]
+      end
+    end
+
+    it "should not allow arrays of 255 entries for tags" do
+      @datastream.tags = []
+      254.times {@datastream.tags << 'a'}
+      @datastream.should_not be_valid
+      @datastream.errors[:tags].should == ["is too long (maximum is 255 characters)"]
+    end
+
+    %w(unit_type current_value).each do |field|
+      it "should allow blank '#{field}'" do
+        @datastream.send("#{field}=".to_sym, nil)
+        @datastream.valid?
+        @datastream.errors[field.to_sym].should be_blank
+      end
+    end
+
+    %w(basicSI derivedSI conversionBasedUnits derivedUnits contextDependentUnits).each do |valid_unit_type|
+      it "should allow unit_type of '#{valid_unit_type}'" do
+        @datastream.unit_type = valid_unit_type
+        @datastream.valid?
+        @datastream.errors[:unit_type].should be_blank
+      end
+    end
+
+    %w(baicSI deriedSI conversinBasedUnits deriedUnits cotextDependentUnits).each do |invalid_unit_type|
+      it "should not allow unit_type of '#{invalid_unit_type}'" do
+        @datastream.unit_type = invalid_unit_type
+        @datastream.valid?
+        @datastream.errors[:unit_type].should == ["is not a valid unit_type (pick one from #{Cosm::Datastream::VALID_UNIT_TYPES.join(', ')} or leave blank)"]
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "should create a blank slate when passed no arguments" do
+      datastream = Cosm::Datastream.new
+      Cosm::Datastream::ALLOWED_KEYS.each do |attr|
+        datastream.attributes[attr.to_sym].should be_nil
+      end
+    end
+
+    %w(xml json hash csv).each do |format|
+      it "should accept #{format}" do
+        datastream = Cosm::Datastream.new(datastream_as_(format.to_sym))
+        datastream.current_value.should == "14"
+      end
+
+      %w(to_csv as_json to_xml to_json attributes).each do |output_format|
+        it "should be able to output from #{format} using #{output_format}" do
+          datastream = Cosm::Datastream.new(datastream_as_(format.to_sym))
+          lambda {datastream.send(output_format.to_sym)}.should_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of datastream properties" do
+      attrs = {}
+      Cosm::Datastream::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["datapoints"] = [Cosm::Datapoint.new({"value" => "ein"})]
+      datastream = Cosm::Datastream.new(attrs)
+
+      datastream.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Cosm::Datastream::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["created_at"] = nil
+      datastream = Cosm::Datastream.new(attrs)
+
+      datastream.attributes.should_not include("created_at")
+    end
+  end
+
+  describe "#attributes=" do
+    it "should accept and save a hash of datastream properties" do
+      datastream = Cosm::Datastream.new({})
+
+      attrs = {}
+      Cosm::Datastream::ALLOWED_KEYS.each do |key|
+        value = "key #{rand(1000)}"
+        attrs[key] = value
+        datastream.should_receive("#{key}=").with(value)
+      end
+      datastream.attributes=(attrs)
+    end
+  end
+
+  context "associated datapoints" do
+
+    describe "#datapoints" do
+      it "should return an array of datapoints" do
+        datapoints = [Cosm::Datapoint.new(datapoint_as_(:hash))]
+        attrs = {"datapoints" => datapoints}
+        datastream = Cosm::Datastream.new(attrs)
+        datastream.datapoints.each do |ds|
+          ds.should be_kind_of(Cosm::Datapoint)
+        end
+      end
+
+      it "should never be nil" do
+        Cosm::Datastream.new({}).datapoints.should == []
+      end
+    end
+
+    describe "#datapoints=" do
+      before(:each) do
+        @datastream = Cosm::Datastream.new({})
+      end
+
+      it "should be empty if not assigned an array" do
+        @datastream.datapoints = "kittens"
+        @datastream.datapoints.should be_empty
+      end
+
+      it "should accept an array of datapoints and hashes and store an array of datapoints" do
+        new_datapoint1 = Cosm::Datapoint.new(datapoint_as_(:hash))
+        new_datapoint2 = Cosm::Datapoint.new(datapoint_as_(:hash))
+        Cosm::Datapoint.should_receive(:new).with(datapoint_as_(:hash)).and_return(new_datapoint2)
+
+        datapoints = [new_datapoint1, datapoint_as_(:hash)]
+        @datastream.datapoints = datapoints
+        @datastream.datapoints.length.should == 2
+        @datastream.datapoints.should include(new_datapoint1)
+        @datastream.datapoints.should include(new_datapoint2)
+      end
+
+      it "should accept an array of datapoints and store an array of datapoints" do
+        datapoints = [Cosm::Datapoint.new(datapoint_as_(:hash))]
+        @datastream.datapoints = datapoints
+        @datastream.datapoints.should == datapoints
+      end
+
+      it "should accept an array of hashes and store an array of datapoints" do
+        new_datapoint = Cosm::Datapoint.new(datapoint_as_(:hash))
+        Cosm::Datapoint.should_receive(:new).with(datapoint_as_(:hash)).and_return(new_datapoint)
+
+        datapoints_hash = [datapoint_as_(:hash)]
+        @datastream.datapoints = datapoints_hash
+        @datastream.datapoints.should == [new_datapoint]
+      end
+    end
+  end
+
+  # Provided by Cosm::Templates::DatastreamDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      datastream = Cosm::Datastream.new({})
+      Cosm::Template.should_receive(:new).with(datastream, :json)
+      lambda {datastream.generate_json("1.0.0")}.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "#to_csv" do
+
+    it "should call the csv generator with default version" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_csv).with("2", {}).and_return("2")
+      datastream.to_csv.should == "2"
+    end
+
+    it "should accept optional xml version" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_csv).with("1", {}).and_return("1234,32")
+      datastream.to_csv(:version => "1").should == "1234,32"
+    end
+
+    it "should accept additional options" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_csv).with("1", {:full => true}).and_return("34")
+      datastream.to_csv(:version => "1", :full => true).should == "34"
+    end
+  end
+
+  describe "#to_xml" do
+
+    it "should call the xml generator with default version" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_xml).with("0.5.1", {}).and_return("<xml></xml>")
+      datastream.to_xml.should == "<xml></xml>"
+    end
+
+    it "should accept optional xml version" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_xml).with("5", {}).and_return("<xml></xml>")
+      datastream.to_xml(:version => "5").should == "<xml></xml>"
+    end
+
+  end
+
+  describe "#as_json" do
+
+    it "should call the json generator with default version" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_json).with("1.0.0", {}).and_return({"title" => "Environment"})
+      datastream.as_json.should == {"title" => "Environment"}
+    end
+
+    it "should accept optional json version" do
+      datastream = Cosm::Datastream.new({})
+      datastream.should_receive(:generate_json).with("0.6-alpha", {}).and_return({"title" => "Environment"})
+      datastream.as_json(:version => "0.6-alpha").should == {"title" => "Environment"}
+    end
+
+  end
+
+  describe "#to_json" do
+    it "should call #as_json" do
+      datastream_hash = {"id" => "env001", "value" => "2344"}
+      datastream = Cosm::Datastream.new(datastream_hash)
+      datastream.should_receive(:as_json).with({})
+      datastream.to_json
+    end
+
+    it "should pass options through to #as_json" do
+      datastream_hash = {"id" => "env001", "value" => "2344"}
+      datastream = Cosm::Datastream.new(datastream_hash)
+      datastream.should_receive(:as_json).with({:crazy => "options"})
+      datastream.to_json({:crazy => "options"})
+    end
+
+    it "should pass the output of #as_json to yajl" do
+      datastream_hash = {"id" => "env001", "value" => "2344"}
+      datastream = Cosm::Datastream.new(datastream_hash)
+      datastream.should_receive(:as_json).and_return({:awesome => "hash"})
+      ::JSON.should_receive(:generate).with({:awesome => "hash"})
+      datastream.to_json
+    end
+  end
+end
+

data/spec/cosm-rb/feed_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+describe Cosm::Feed do
+
+  it "should have a constant that defines the allowed keys" do
+    Cosm::Feed::ALLOWED_KEYS.should == %w(id creator owner_login datastreams description email feed icon location_disposition location_domain location_ele location_exposure location_lat location_lon location_name location_waypoints private status tags title updated created website auto_feed_url csv_version)
+  end
+
+  context "attr accessors" do
+    before(:each) do
+      @feed = Cosm::Feed.new(feed_as_(:json))
+    end
+
+    describe "setting whitelisted fields" do
+      Cosm::Feed::ALLOWED_KEYS.each do |key|
+        it "##{key}=" do
+          lambda {
+            @feed.send("#{key}=", key)
+          }.should_not raise_error
+        end
+      end
+    end
+
+    describe "getting whitelisted fields" do
+      Cosm::Feed::ALLOWED_KEYS.each do |key|
+        it "##{key}" do
+          lambda {
+            @feed.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 {
+          @feed.something_bogus = 'whatevs'
+        }.should raise_error
+      end
+
+      it "should not be possible to get non-whitelisted fields" do
+        lambda {
+          @feed.something_bogus
+        }.should raise_error
+      end
+    end
+  end
+
+  describe "validation" do
+    %w(title).each do |field|
+      it "should require a '#{field}'" do
+        feed = Cosm::Feed.new
+        feed.send("#{field}=".to_sym, nil)
+        feed.should_not be_valid
+        feed.errors[field.to_sym].should == ["can't be blank"]
+      end
+    end
+
+    it "should not allow duplicate datastreams" do
+      feed = Cosm::Feed.new
+      feed.datastreams = [Cosm::Datastream.new('id' => '1'), Cosm::Datastream.new('id' => '1')]
+      feed.should_not be_valid
+      feed.errors[:datastreams].should == ["can't have duplicate IDs: 1"]
+    end
+
+    it "should validate all datastreams" do
+      feed = Cosm::Feed.new
+      feed.datastreams = [Cosm::Datastream.new('id' => '')]
+      feed.should_not be_valid
+      feed.errors[:datastreams_id].should == ["can't be blank"]
+    end
+  end
+
+  describe "#initialize" do
+    it "should create a blank slate when passed no arguments" do
+      feed = Cosm::Feed.new
+      Cosm::Feed::ALLOWED_KEYS.each do |attr|
+        feed.attributes[attr.to_sym].should be_nil
+      end
+    end
+
+    %w(xml json hash).each do |format|
+      it "should accept #{format}" do
+        feed = Cosm::Feed.new(feed_as_(format.to_sym))
+        feed.title.downcase.should == "cosm office environment"
+      end
+
+      %w(to_csv as_json to_xml to_json attributes).each do |output_format|
+        it "should be able to output from #{format} using #{output_format}" do
+          feed = Cosm::Feed.new(feed_as_(format.to_sym))
+          lambda {feed.send(output_format.to_sym)}.should_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of feed properties" do
+      attrs = {}
+      Cosm::Feed::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["datastreams"] = [Cosm::Datastream.new({"id" => "ein"})]
+      feed = Cosm::Feed.new(attrs)
+
+      feed.attributes.should == attrs
+    end
+
+    it "should contain csv_version in the allowed keys" do
+      Cosm::Feed::ALLOWED_KEYS.should include("csv_version")
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Cosm::Feed::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["created_at"] = nil
+      feed = Cosm::Feed.new(attrs)
+
+      feed.attributes.should_not include("created_at")
+    end
+  end
+
+  describe "#attributes=" do
+    it "should accept and save a hash of feed properties" do
+      feed = Cosm::Feed.new({})
+
+      attrs = {}
+      Cosm::Feed::ALLOWED_KEYS.each do |key|
+        value = "key #{rand(1000)}"
+        attrs[key] = value
+        feed.should_receive("#{key}=").with(value)
+      end
+      feed.attributes=(attrs)
+    end
+  end
+
+  context "associated datastreams" do
+
+    describe "#datastreams" do
+      it "should return an array of datastreams" do
+        datastreams = [Cosm::Datastream.new(datastream_as_(:hash))]
+        attrs = {"datastreams" => datastreams}
+        feed = Cosm::Feed.new(attrs)
+        feed.datastreams.each do |ds|
+          ds.should be_kind_of(Cosm::Datastream)
+        end
+      end
+
+      it "should default to an empty array" do
+        feed = Cosm::Feed.new({})
+        feed.datastreams.should == []
+      end
+    end
+
+    describe "#datastreams=" do
+      before(:each) do
+        @feed = Cosm::Feed.new({})
+      end
+
+      it "should return an empty array if not an array" do
+        @feed.datastreams = "kittens"
+        @feed.datastreams.should be_empty
+      end
+
+      it "should accept an array of datastreams and hashes and store an array of datastreams" do
+        new_datastream1 = Cosm::Datastream.new(datastream_as_(:hash))
+        new_datastream2 = Cosm::Datastream.new(datastream_as_(:hash))
+        Cosm::Datastream.should_receive(:new).with(datastream_as_(:hash)).and_return(new_datastream2)
+
+        datastreams = [new_datastream1, datastream_as_(:hash)]
+        @feed.datastreams = datastreams
+        @feed.datastreams.length.should == 2
+        @feed.datastreams.should include(new_datastream1)
+        @feed.datastreams.should include(new_datastream2)
+      end
+
+      it "should accept an array of datastreams and store an array of datastreams" do
+        datastreams = [Cosm::Datastream.new(datastream_as_(:hash))]
+        @feed.datastreams = datastreams
+        @feed.datastreams.should == datastreams
+      end
+
+      it "should accept an array of hashes and store an array of datastreams" do
+        new_datastream = Cosm::Datastream.new(datastream_as_(:hash))
+        Cosm::Datastream.should_receive(:new).with(datastream_as_(:hash)).and_return(new_datastream)
+
+        datastreams_hash = [datastream_as_(:hash)]
+        @feed.datastreams = datastreams_hash
+        @feed.datastreams.should == [new_datastream]
+      end
+
+      it "should accept an array of subclass of datastream and store an array of datastreams" do
+        class OurSpecialDatastreamClass < Cosm::Datastream
+          attr_accessor :something_new
+        end
+
+        datastreams = [OurSpecialDatastreamClass.new(datastream_as_(:hash))]
+        @feed.datastreams = datastreams
+        @feed.datastreams.should == datastreams
+      end
+    end
+
+  end
+
+  # Provided by Cosm::Templates::FeedDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      feed = Cosm::Feed.new({})
+      Cosm::Template.should_receive(:new).with(feed, :json)
+      lambda {feed.generate_json("1.0.0", {})}.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "#to_csv" do
+    it "should call the csv generator with default version" do
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_csv).with("2", {}).and_return("1,2,3,4")
+      feed.to_csv.should == "1,2,3,4"
+    end
+
+    it "should accept optional csv version" do
+      version = "1"
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_csv).with(version, {}).and_return("1,2,3,4")
+      feed.to_csv(:version => version).should == "1,2,3,4"
+    end
+
+    it "should accept additional options" do
+      version = "1"
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_csv).with(version, :full => true).and_return("1,2,3,4")
+      feed.to_csv(:version => version, :full => true).should == "1,2,3,4"
+    end
+  end
+
+  describe "#to_xml" do
+    it "should call the xml generator with default version" do
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_xml).with("0.5.1", {}).and_return("<xml></xml>")
+      feed.to_xml.should == "<xml></xml>"
+    end
+
+    it "should accept optional xml version" do
+      version = "5"
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_xml).with(version, {}).and_return("<xml></xml>")
+      feed.to_xml(:version => version).should == "<xml></xml>"
+    end
+  end
+
+  describe "#as_json" do
+    it "should call the json generator with default version" do
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_json).with("1.0.0", {}).and_return({"title" => "Environment"})
+      feed.as_json.should == {"title" => "Environment"}
+    end
+
+    it "should accept optional json version" do
+      version = "0.6-alpha"
+      feed = Cosm::Feed.new({})
+      feed.should_receive(:generate_json).with(version, {}).and_return({"title" => "Environment"})
+      feed.as_json(:version => version).should == {"title" => "Environment"}
+    end
+  end
+
+  describe "#to_json" do
+    it "should call #as_json" do
+      feed_hash = {"title" => "Environment"}
+      feed = Cosm::Feed.new(feed_hash)
+      feed.should_receive(:as_json).with({})
+      feed.to_json
+    end
+
+    it "should pass options through to #as_json" do
+      feed_hash = {"title" => "Environment"}
+      feed = Cosm::Feed.new(feed_hash)
+      feed.should_receive(:as_json).with({:crazy => "options"})
+      feed.to_json({:crazy => "options"})
+    end
+
+    it "should generate datastreams" do
+      feed = Cosm::Feed.new(feed_as_('hash'))
+      feed.datastreams = datastream_as_(:hash)
+      JSON.parse(feed.to_json)["datastreams"].should_not be_nil
+    end
+
+    it "should pass the output of #as_json to yajl" do
+      feed_hash = {"title" => "Environment"}
+      feed = Cosm::Feed.new(feed_hash)
+      feed.should_receive(:as_json).and_return({:awesome => "hash"})
+      ::JSON.should_receive(:generate).with({:awesome => "hash"})
+      feed.to_json
+    end
+  end
+end
+

data/spec/cosm-rb/hash_extensions_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "Hash extensions" do
+  it "should add a delete_if_nil_value method to hashes" do
+    hash = { "foo" => "awesome", "bar" => nil, :symbol => "" }
+    hash.delete_if_nil_value.should == { "foo" => "awesome" }
+  end
+
+  # HACK probably
+  it "should add a deep_stringify_keys method to hash instances" do
+    hash = { :sym => "val", :nested => { "str" => 12, :symtoo => 58 } }
+    hash.deep_stringify_keys.should == { "sym" => "val", "nested" => { "str" => 12, "symtoo" => 58 } }
+  end
+
+  it "should have a destructive in place version of the deep_stringify_keys method" do
+    hash = { :sym => "val", :nested => { "str" => 12, :symtoo => 58 } }
+    hash.deep_stringify_keys!
+    hash.should == { "sym" => "val", "nested" => { "str" => 12, "symtoo" => 58 } }
+  end
+end

data/spec/cosm-rb/helpers_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Template helpers" do
+  include Cosm::Helpers
+
+  describe "#join_tags" do
+
+    it "should just return the string if it already is one" do
+      join_tags('help, me').should == 'help, me'
+    end
+
+    it "should convert an array into a string" do
+      join_tags(['bag', 'jag', 'lag', 'tag']).should == 'bag,jag,lag,tag'
+    end
+
+    it "should sort the array" do
+      join_tags(['zag', 'xag', 'Bag', 'aag']).should == 'aag,Bag,xag,zag'
+    end
+  end
+
+  describe "#parse_tag_string" do
+    it "should handle single tags" do
+      parse_tag_string('tag').should == ['tag']
+    end
+
+    it "should handle multiple tags" do
+      parse_tag_string('tag, bag ,lag,jag').should == ['bag', 'jag', 'lag', 'tag']
+    end
+
+    it "should handle complex tags" do
+      string = 'apple, orange, "red room", "  I like space  ", "tennis, later"'
+      parse_tag_string(string).should == 
+        [
+          "  I like space  ",
+          "apple",
+          "orange",
+          "red room",
+          "tennis, later"
+        ]
+    end
+
+    it "should handle tags with escaped double quote" do
+      string = 'apple, orange, "horse:height=2\"", "  I like space  ", "tennis, later", "\"quote\""'
+      parse_tag_string(string).should == 
+        [
+          "  I like space  ",
+          "\"quote\"",
+          "apple",
+          "horse:height=2\"",
+          "orange",
+          "tennis, later"
+        ]
+    end
+  end
+end
+