xively-rb 0.2.09

data/spec/xively-rb/base_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Xively::Base do
+  describe "#is_xively" do
+    it "should take a class name and a hash of options" do
+      lambda { Feed.is_xively }.should raise_error(ArgumentError, "wrong number of arguments (0 for 1)")
+      lambda { Feed.is_xively(:feed, {}, "bogus third arg") }.should raise_error(ArgumentError, "wrong number of arguments (3 for 2)")
+    end
+
+    it "should assign mapping class" do
+      class TestClass
+        extend Xively::Base
+        is_xively :datastream
+      end
+      TestClass.xively_class.should == Xively::Datastream
+    end
+
+    it "should assign mapping class for datapoints" do
+      class TestClass
+        extend Xively::Base
+        is_xively :datapoint
+      end
+      TestClass.xively_class.should == Xively::Datapoint
+    end
+
+    it "should not assign mapping class if unrecognized" do
+      class TestClass
+        extend Xively::Base
+        is_xively :hero_stream
+      end
+      TestClass.xively_class.should be_nil
+    end
+
+    it "should assign optional mappings" do
+      class TestClass
+        extend Xively::Base
+        is_xively :feed, {:title => :custom_method, :website => :custom_method}
+        def custom_method
+          "Custom title"
+        end
+      end
+      TestClass.xively_mappings.should == {:title => :custom_method, :website => :custom_method}
+    end
+
+    it "should include our instance methods into a class when we call it" do
+      class TestClass
+        extend Xively::Base
+      end
+      TestClass.should_receive(:include).with(Xively::Base::InstanceMethods)
+      class TestClass
+        is_xively :feed
+      end
+    end
+  end
+end
+

data/spec/xively-rb/client_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe "Xively::Client" do
+  before do
+    @client = Xively::Client.new("abcdefg")
+  end
+
+  it "should have the base uri defined" do
+    Xively::Client.base_uri.should == 'https://api.xively.com'
+  end
+
+  it "should be initializable with an api key" do
+    @client.api_key.should eql("abcdefg")
+  end
+
+  describe "#get" do
+    it "should make the appropriate request" do
+      request_stub = stub_request(:get, "#{Xively::Client.base_uri}/v2/feeds/504.json").
+        with(:headers => {'User-Agent' => Xively::Client.user_agent, 'X-ApiKey' => 'abcdefg'})
+      @client.get('/v2/feeds/504.json')
+      request_stub.should have_been_made
+    end
+  end
+
+  describe "#put" do
+    it "should make the appropriate request" do
+      request_stub = stub_request(:put, "#{Xively::Client.base_uri}/v2/feeds/504.json").
+        with(:headers => {'User-Agent' => Xively::Client.user_agent, 'X-ApiKey' => 'abcdefg'}, :body => "dataz")
+      @client.put('/v2/feeds/504.json', :body => "dataz")
+      request_stub.should have_been_made
+    end
+  end
+
+  describe "#post" do
+    it "should make the appropriate request" do
+      request_stub = stub_request(:post, "#{Xively::Client.base_uri}/v2/feeds/504.json").
+        with(:headers => {'User-Agent' => Xively::Client.user_agent, 'X-ApiKey' => 'abcdefg'}, :body => "dataz")
+      @client.post('/v2/feeds/504.json', :body => "dataz")
+      request_stub.should have_been_made
+    end
+  end
+
+  describe "#delete" do
+    it "should make the appropriate request" do
+      request_stub = stub_request(:delete, "#{Xively::Client.base_uri}/v2/feeds/504/datastreams/test.json").
+        with(:headers => {'User-Agent' => Xively::Client.user_agent, 'X-ApiKey' => 'abcdefg'})
+      @client.delete('/v2/feeds/504/datastreams/test.json')
+      request_stub.should have_been_made
+    end
+  end
+end

data/spec/xively-rb/datapoint_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe Xively::Datapoint do
+
+  it "should have a constant that defines the allowed keys" do
+    Xively::Datapoint::ALLOWED_KEYS.should == %w(feed_id datastream_id at value)
+  end
+
+  describe "validation" do
+    before(:each) do
+      @datapoint = Xively::Datapoint.new
+    end
+
+    %w(datastream_id value feed_id).each do |field|
+      it "should require a '#{field}'" do
+        @datapoint.send("#{field}=".to_sym, nil)
+        @datapoint.should_not be_valid
+        @datapoint.errors[field.to_sym].should include("can't be blank")
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "should create a blank slate when passed no arguments" do
+      datapoint = Xively::Datapoint.new
+      Xively::Datapoint::ALLOWED_KEYS.each do |attr|
+        datapoint.attributes[attr.to_sym].should be_nil
+      end
+    end
+
+    it "should accept xml" do
+      datapoint = Xively::Datapoint.new(datapoint_as_(:xml))
+      datapoint.value.should == "2000"
+    end
+
+    it "should accept json" do
+      datapoint = Xively::Datapoint.new(datapoint_as_(:json))
+      datapoint.value.should == "2000"
+    end
+
+    it "should accept a hash of attributes" do
+      datapoint = Xively::Datapoint.new(datapoint_as_(:hash))
+      datapoint.value.should == "2000"
+    end
+
+    it "should raise known exception if passed json but told xml" do
+      expect {
+        Xively::Datapoint.new(datapoint_as_(:json), :xml)
+      }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+    end
+
+    it "should raise known exception if passed xml but told json" do
+      expect {
+        Xively::Datapoint.new(datapoint_as_(:xml), :json)
+      }.to raise_error(Xively::Parsers::JSON::InvalidJSONError)
+    end
+
+    it "should raise known exception if given unknown format" do
+      expect {
+        Xively::Datapoint.new(datapoint_as_(:json), :msgpack)
+      }.to raise_error(Xively::InvalidFormatError)
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of datapoint properties" do
+      attrs = {}
+      Xively::Datapoint::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      datapoint = Xively::Datapoint.new(attrs)
+
+      datapoint.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Xively::Datapoint::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["created_at"] = nil
+      datapoint = Xively::Datapoint.new(attrs)
+
+      datapoint.attributes.should_not include("created_at")
+    end
+  end
+
+  describe "#attributes=" do
+    it "should accept and save a hash of datapoint properties" do
+      datapoint = Xively::Datapoint.new({})
+
+      attrs = {}
+      Xively::Datapoint::ALLOWED_KEYS.each do |key|
+        value = "key #{rand(1000)}"
+        attrs[key] = value
+        datapoint.should_receive("#{key}=").with(value)
+      end
+      datapoint.attributes=(attrs)
+    end
+  end
+
+  # Provided by Xively::Templates::DatapointDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      now = Time.now
+      datapoint = Xively::Datapoint.new({:at => now, :value => 123})
+      datapoint.generate_json.should == {:at => now.iso8601(6), :value => 123}
+    end
+  end
+
+  describe "#to_csv" do
+    it "should call the csv generator with default version (nil as there only is one version)" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_csv).with(nil, {}).and_return("3")
+      datapoint.to_csv.should == "3"
+    end
+
+    it "should accept optional csv version" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_csv).with("1", {}).and_return("34")
+      datapoint.to_csv(:version => "1").should == "34"
+    end
+
+    it "should accept additional options" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_csv).with("1", {:full => true}).and_return("34")
+      datapoint.to_csv(:version => "1", :full => true).should == "34"
+    end
+  end
+
+  describe "#to_xml" do
+
+    it "should call the xml generator with default version (nil as there only is one version)" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_xml).with(nil).and_return("<xml></xml>")
+      datapoint.to_xml.should == "<xml></xml>"
+    end
+
+    it "should accept optional xml version" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_xml).with("5").and_return("<xml></xml>")
+      datapoint.to_xml(:version => "5").should == "<xml></xml>"
+    end
+
+  end
+
+  describe "#as_json" do
+
+    it "should call the json generator with default version (nil as there only is one version)" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_json).with(nil).and_return({"title" => "Environment"})
+      datapoint.as_json.should == {"title" => "Environment"}
+    end
+
+    it "should accept optional json version" do
+      datapoint = Xively::Datapoint.new({})
+      datapoint.should_receive(:generate_json).with("0.6-alpha").and_return({"title" => "Environment"})
+      datapoint.as_json(:version => "0.6-alpha").should == {"title" => "Environment"}
+    end
+
+  end
+
+  describe "#to_json" do
+    it "should call #as_json" do
+      datapoint_hash = {"id" => "env001", "value" => "2344"}
+      datapoint = Xively::Datapoint.new(datapoint_hash)
+      datapoint.should_receive(:as_json).with({})
+      datapoint.to_json
+    end
+
+    it "should pass options through to #as_json" do
+      datapoint_hash = {"id" => "env001", "value" => "2344"}
+      datapoint = Xively::Datapoint.new(datapoint_hash)
+      datapoint.should_receive(:as_json).with({:crazy => "options"})
+      datapoint.to_json({:crazy => "options"})
+    end
+
+    it "should pass the output of #as_json to yajl" do
+      datapoint_hash = {"id" => "env001", "value" => "2344"}
+      datapoint = Xively::Datapoint.new(datapoint_hash)
+      datapoint.should_receive(:as_json).and_return({:awesome => "hash"})
+      MultiJson.should_receive(:dump).with({:awesome => "hash"})
+      datapoint.to_json
+    end
+  end
+end
+

data/spec/xively-rb/datastream_spec.rb

@@ -0,0 +1,344 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Xively::Datastream do
+
+  it "should have a constant that defines the allowed keys" do
+    Xively::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 = Xively::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 #{Xively::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 = Xively::Datastream.new
+      Xively::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 = Xively::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 = Xively::Datastream.new(datastream_as_(format.to_sym))
+          lambda {datastream.send(output_format.to_sym)}.should_not raise_error
+        end
+      end
+    end
+
+    it "should raise known exception if passed json but told xml" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:json), :v2, :xml)
+      }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+    end
+
+    it "should raise known exception if passed csv but told xml" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:csv), :v2, :xml)
+      }.to raise_error(Xively::Parsers::XML::InvalidXMLError)
+    end
+
+    it "should raise known exception if passed xml but told json" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:xml), :v2, :json)
+      }.to raise_error(Xively::Parsers::JSON::InvalidJSONError)
+    end
+
+    it "should raise known exception if passed csv but told json" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:csv), :v2, :json)
+      }.to raise_error(Xively::Parsers::JSON::InvalidJSONError)
+    end
+
+    it "should raise known exception if passed json but told csv" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:json), :v2, :csv)
+      }.to raise_error(Xively::Parsers::CSV::InvalidCSVError)
+    end
+
+    it "should raise known exception if passed xml but told csv" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:xml), :v2, :csv)
+      }.to raise_error(Xively::Parsers::CSV::InvalidCSVError)
+    end
+
+    it "should raise known exception if told some format we don't accept" do
+      expect {
+        Xively::Datastream.new(datastream_as_(:xml), :v2, :html)
+      }.to raise_error(Xively::InvalidFormatError)
+    end
+
+  end
+
+  describe "#attributes" do
+    it "should return a hash of datastream properties" do
+      attrs = {}
+      Xively::Datastream::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["datapoints"] = [Xively::Datapoint.new({"value" => "ein"})]
+      datastream = Xively::Datastream.new(attrs)
+
+      datastream.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Xively::Datastream::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["created_at"] = nil
+      datastream = Xively::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 = Xively::Datastream.new({})
+
+      attrs = {}
+      Xively::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 = [Xively::Datapoint.new(datapoint_as_(:hash))]
+        attrs = {"datapoints" => datapoints}
+        datastream = Xively::Datastream.new(attrs)
+        datastream.datapoints.each do |ds|
+          ds.should be_kind_of(Xively::Datapoint)
+        end
+      end
+
+      it "should never be nil" do
+        Xively::Datastream.new({}).datapoints.should == []
+      end
+    end
+
+    describe "#datapoints=" do
+      before(:each) do
+        @datastream = Xively::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 = Xively::Datapoint.new(datapoint_as_(:hash))
+        new_datapoint2 = Xively::Datapoint.new(datapoint_as_(:hash))
+        Xively::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 = [Xively::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 = Xively::Datapoint.new(datapoint_as_(:hash))
+        Xively::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 Xively::Templates::DatastreamDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      datastream = Xively::Datastream.new({})
+      datastream.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
+      datastream = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::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 = Xively::Datastream.new(datastream_hash)
+      datastream.should_receive(:as_json).and_return({:awesome => "hash"})
+      MultiJson.should_receive(:dump).with({:awesome => "hash"})
+      datastream.to_json
+    end
+  end
+end
+