xively-rb 0.2.09

data/spec/xively-rb/feed_spec.rb

@@ -0,0 +1,341 @@
+require 'spec_helper'
+
+describe Xively::Feed do
+
+  it "should have a constant that defines the allowed keys" do
+    Xively::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 product_id device_serial csv_version)
+  end
+
+  context "attr accessors" do
+    before(:each) do
+      @feed = Xively::Feed.new(feed_as_(:json))
+    end
+
+    describe "setting whitelisted fields" do
+      Xively::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
+      Xively::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 = Xively::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 = Xively::Feed.new
+      feed.datastreams = [Xively::Datastream.new('id' => '1'), Xively::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 = Xively::Feed.new
+      feed.datastreams = [Xively::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 = Xively::Feed.new
+      Xively::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 = Xively::Feed.new(feed_as_(format.to_sym))
+        feed.title.downcase.should == "xively 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 = Xively::Feed.new(feed_as_(format.to_sym))
+          lambda {feed.send(output_format.to_sym)}.should_not raise_error
+        end
+      end
+    end
+
+    context "specifying format" do
+      it "should raise known exception if told xml but given csv" do
+        expect {
+          Xively::Feed.new(feed_as_(:csv), :v2, :xml)
+        }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+      end
+
+      it "should raise known exception if told xml but given json" do
+        expect {
+          Xively::Feed.new(feed_as_(:json), nil, :xml)
+        }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+      end
+
+      it "should raise known exception if told json but given xml" do
+        expect {
+          Xively::Feed.new(feed_as_(:xml), nil, :json)
+        }.to raise_error(Xively::Parsers::JSON::InvalidJSONError)
+      end
+
+      it "should raise known exception if told json but given csv" do
+        expect {
+          Xively::Feed.new(feed_as_(:csv), nil, :json)
+        }.to raise_error(Xively::Parsers::JSON::InvalidJSONError)
+      end
+
+      it "should raise known exception if told csv but given xml" do
+        expect {
+          Xively::Feed.new(feed_as_(:xml), :v2, :csv)
+        }.to raise_error(Xively::Parsers::CSV::InvalidCSVError)
+      end
+
+      it "should raise known exception if told csv but given json" do
+        expect {
+          Xively::Feed.new(feed_as_(:json), :v2, :csv)
+        }.to raise_error(Xively::Parsers::CSV::InvalidCSVError)
+      end
+
+      it "should raise known exception if told format is something unknown" do
+        expect {
+          Xively::Feed.new(feed_as_(:json), :v2, :msgpack)
+        }.to raise_error(Xively::InvalidFormatError)
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of feed properties" do
+      attrs = {}
+      Xively::Feed::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["datastreams"] = [Xively::Datastream.new({"id" => "ein"})]
+      feed = Xively::Feed.new(attrs)
+
+      feed.attributes.should == attrs
+    end
+
+    it "should contain csv_version in the allowed keys" do
+      Xively::Feed::ALLOWED_KEYS.should include("csv_version")
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Xively::Feed::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["created_at"] = nil
+      feed = Xively::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 = Xively::Feed.new({})
+
+      attrs = {}
+      Xively::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 = [Xively::Datastream.new(datastream_as_(:hash))]
+        attrs = {"datastreams" => datastreams}
+        feed = Xively::Feed.new(attrs)
+        feed.datastreams.each do |ds|
+          ds.should be_kind_of(Xively::Datastream)
+        end
+      end
+
+      it "should default to an empty array" do
+        feed = Xively::Feed.new({})
+        feed.datastreams.should == []
+      end
+    end
+
+    describe "#datastreams=" do
+      before(:each) do
+        @feed = Xively::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 = Xively::Datastream.new(datastream_as_(:hash))
+        new_datastream2 = Xively::Datastream.new(datastream_as_(:hash))
+        Xively::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 = [Xively::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 = Xively::Datastream.new(datastream_as_(:hash))
+        Xively::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 < Xively::Datastream
+          attr_accessor :something_new
+        end
+
+        datastreams = [OurSpecialDatastreamClass.new(datastream_as_(:hash))]
+        @feed.datastreams = datastreams
+        @feed.datastreams.should == datastreams
+      end
+    end
+
+  end
+
+  # Provided by Xively::Templates::FeedDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      feed = Xively::Feed.new({})
+      feed.generate_json("1.0.0").should == {:version => "1.0.0"}
+    end
+  end
+
+  describe "#to_csv" do
+    it "should call the csv generator with default version" do
+      feed = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::Feed.new(feed_hash)
+      feed.should_receive(:as_json).with({:crazy => "options"})
+      feed.to_json({:crazy => "options"})
+    end
+
+    it "should generate datastreams" do
+      feed = Xively::Feed.new(feed_as_('hash'))
+      feed.datastreams = datastream_as_(:hash)
+      MultiJson.load(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 = Xively::Feed.new(feed_hash)
+      feed.should_receive(:as_json).and_return({:awesome => "hash"})
+      MultiJson.should_receive(:dump).with({:awesome => "hash"})
+      feed.to_json
+    end
+  end
+end
+

data/spec/xively-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/xively-rb/helpers_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Template helpers" do
+  include Xively::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
+

data/spec/xively-rb/key_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe Xively::Key do
+  it "should have a constant that defines the allowed keys" do
+    Xively::Key::ALLOWED_KEYS.sort.should == %w(expires_at id key label user permissions private_access).sort
+  end
+
+  describe "validation" do
+    before(:each) do
+      @key = Xively::Key.new
+    end
+
+    %w(label permissions user).each do |field|
+      it "should require a '#{field}'" do
+        @key.send("#{field}=".to_sym, nil)
+        @key.should_not be_valid
+        @key.errors[field.to_sym].should include("can't be blank")
+      end
+    end
+
+    it "should not be valid if resource present with no feed_id" do
+      @key.attributes = { :user => "bob", :permissions => [ { :access_methods => ["get"], :resources => [{}] } ] }
+      @key.should_not be_valid
+    end
+
+    it "should not be valid if we have a datastream_id with no feed_id in a resource" do
+      @key.attributes = { :user => "bob", :permissions => [ { :access_methods => ["get"], :resources => [{:datastream_id => "0"}] } ] }
+      @key.should_not be_valid
+    end
+
+    it "should always return a boolean from the permission private_access? attribute, even if nil" do
+      @key.private_access.should be_nil
+      @key.private_access?.should be_false
+      @key.private_access = true
+      @key.private_access?.should be_true
+    end
+
+    it "should not be valid if a permission object with no methods is added" do
+      @key.attributes = { :user => "bob", :permissions => [ { :label => "label" } ] }
+      @key.should_not be_valid
+      @key.errors[:permissions_access_methods].should include("can't be blank")
+    end
+
+    it "should return the key as the id if no id attribute is specified" do
+      hash = key_as_(:hash)
+      hash.delete("id")
+      @key.attributes = hash
+      @key.id.should == "abcdefghasdfaoisdj109usasdf0a9sf"
+    end
+  end
+
+  describe "#initialize" do
+    it "should create a blank slate when passed no arguments" do
+      key = Xively::Key.new
+      Xively::Key::ALLOWED_KEYS.each do |attr|
+        key.attributes[attr.to_sym].should be_nil
+      end
+    end
+
+    it "should accept xml" do
+      key = Xively::Key.new(key_as_(:xml))
+      key.permissions.first.access_methods.should == ["get", "put", "post", "delete"]
+    end
+
+    it "should accept json" do
+      key = Xively::Key.new(key_as_(:json))
+      key.permissions.first.access_methods.should == ["get", "put", "post", "delete"]
+    end
+
+    it "should accept a hash of attributes" do
+      key = Xively::Key.new(key_as_(:hash))
+      key.permissions.first.access_methods.should == ["get", "put", "post", "delete"]
+    end
+
+    context "specifying format" do
+      it "should raise known exception if told xml but given json" do
+        expect {
+          Xively::Key.new(key_as_(:json), :xml)
+        }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+      end
+
+      it "should raise known exception if told json but given xml" do
+        expect {
+          Xively::Key.new(key_as_(:xml), :json)
+        }.to raise_error(Xively::Parsers::JSON::InvalidJSONError)
+      end
+
+      it "should raise known exception if given unknown format" do
+        expect {
+          Xively::Key.new(key_as_(:xml), :gif)
+        }.to raise_error(Xively::InvalidFormatError)
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of key properties" do
+      attrs = {}
+      Xively::Key::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["permissions"] = [Xively::Permission.new(:permissions => [:get])]
+      key = Xively::Key.new(attrs)
+
+      key.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Xively::Key::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["notified_at"] = nil
+      key = Xively::Key.new(attrs)
+
+      key.attributes.should_not include("notified_at")
+    end
+  end
+
+  describe "#attributes=" do
+    it "should accept and save a hash of properties" do
+      key = Xively::Key.new({})
+
+      attrs = {}
+      Xively::Key::ALLOWED_KEYS.each do |attr|
+        value = "key #{rand(1000)}"
+        attrs[attr] = value
+        key.should_receive("#{attr}=").with(value)
+      end
+      key.attributes=(attrs)
+    end
+
+    it "should accept deep nested attributes for permissions array" do
+      key = Xively::Key.new({})
+      key.attributes = { :permissions_attributes => [{:label => "label", :access_methods => [:get, :put], :resources_attributes => [{:feed_id => 123, :datastream_id => "0"}]}] }
+      key.permissions.size.should == 1
+      key.permissions.first.label.should == "label"
+      key.permissions.first.resources.size.should == 1
+      key.permissions.first.resources.first.feed_id.should == 123
+    end
+
+    it "should set deep nested attributes using class instances as well (not just hashes of attributes)" do
+      resource = Xively::Resource.new(:feed_id => 123)
+      permission = Xively::Permission.new(:label => "label", :access_methods => [:get], :resources => [resource])
+      key = Xively::Key.new(:permissions => [permission])
+      key.permissions.size.should == 1
+      key.permissions.first.resources.size.should == 1
+    end
+  end
+
+  describe "#as_json" do
+    it "should call the json generator" do
+      options = {:include_blanks => true}
+      key = Xively::Key.new
+      key.should_receive(:generate_json).with(options).and_return({"permissions" => [:get, :put]})
+      key.as_json(options).should == {"permissions" => [:get, :put]}
+    end
+
+    it "should accept *very* nil options" do
+      key = Xively::Key.new
+      key.should_receive(:generate_json).with({}).and_return({"permissions" => [:get, :put]})
+      key.as_json(nil).should == {"permissions" => [:get, :put]}
+    end
+
+    it "should return iso8601 formatted expires_at string if present" do
+      time = Time.now
+      key = Xively::Key.new(:expires_at => time)
+      key.as_json[:key][:expires_at].should == time.iso8601(6)
+    end
+  end
+
+  describe "#to_json" do
+    before(:each) do
+      @time = Time.now
+      @key_hash = { "label" => "label", :expires_at => @time, "permissions" => [{"permissions" => [:get, :put, :post], :resources => [{:feed_id => 504, :datastream_id => "0"}]}] }
+    end
+
+    it "should call #as_json" do
+      key = Xively::Key.new(@key_hash)
+      key.should_receive(:as_json).with(nil)
+      key.to_json
+    end
+
+    it "should pass options through to #as_json" do
+      key = Xively::Key.new(@key_hash)
+      key.should_receive(:as_json).with({:crazy => "options"})
+      key.to_json({:crazy => "options"})
+    end
+
+    it "should pass the output of #as_json to yajl" do
+      key = Xively::Key.new(@key_hash)
+      key.should_receive(:as_json).and_return({:awesome => "hash"})
+      MultiJson.should_receive(:dump).with({:awesome => "hash"})
+      key.to_json
+    end
+  end
+
+end